void BSONObjBuilder::appendMinForType( const StringData& fieldName , int t ) { switch ( t ) { // Shared canonical types case NumberInt: case NumberDouble: case NumberLong: append( fieldName , - std::numeric_limits<double>::max() ); return; case Symbol: case String: append( fieldName , "" ); return; case Date: // min varies with V0 and V1 indexes, so we go one type lower. appendBool(fieldName, true); //appendDate( fieldName , numeric_limits<long long>::min() ); return; case Timestamp: // TODO integrate with Date SERVER-3304 appendTimestamp( fieldName , 0 ); return; case Undefined: // shared with EOO appendUndefined( fieldName ); return; // Separate canonical types case MinKey: appendMinKey( fieldName ); return; case MaxKey: appendMaxKey( fieldName ); return; case jstOID: { OID o; appendOID( fieldName , &o); return; } case Bool: appendBool( fieldName , false); return; case jstNULL: appendNull( fieldName ); return; case Object: append( fieldName , BSONObj() ); return; case Array: appendArray( fieldName , BSONObj() ); return; case BinData: appendBinData( fieldName , 0 , BinDataGeneral , (const char *) 0 ); return; case RegEx: appendRegex( fieldName , "" ); return; case DBRef: { OID o; appendDBRef( fieldName , "" , o ); return; } case Code: appendCode( fieldName , "" ); return; case CodeWScope: appendCodeWScope( fieldName , "" , BSONObj() ); return; }; log() << "type not supported for appendMinElementForType: " << t; uassert( 10061 , "type not supported for appendMinElementForType" , false ); }
void SVGPathStringBuilder::emitSegment(const PathSegmentData& segment) { ASSERT(segment.command > PathSegUnknown && segment.command <= PathSegCurveToQuadraticSmoothRel); m_stringBuilder.append(pathSegmentCharacter[segment.command]); switch (segment.command) { case PathSegMoveToRel: case PathSegMoveToAbs: case PathSegLineToRel: case PathSegLineToAbs: case PathSegCurveToQuadraticSmoothRel: case PathSegCurveToQuadraticSmoothAbs: appendPoint(m_stringBuilder, segment.targetPoint); break; case PathSegLineToHorizontalRel: case PathSegLineToHorizontalAbs: appendFloat(m_stringBuilder, segment.targetPoint.x()); break; case PathSegLineToVerticalRel: case PathSegLineToVerticalAbs: appendFloat(m_stringBuilder, segment.targetPoint.y()); break; case PathSegClosePath: break; case PathSegCurveToCubicRel: case PathSegCurveToCubicAbs: appendPoint(m_stringBuilder, segment.point1); appendPoint(m_stringBuilder, segment.point2); appendPoint(m_stringBuilder, segment.targetPoint); break; case PathSegCurveToCubicSmoothRel: case PathSegCurveToCubicSmoothAbs: appendPoint(m_stringBuilder, segment.point2); appendPoint(m_stringBuilder, segment.targetPoint); break; case PathSegCurveToQuadraticRel: case PathSegCurveToQuadraticAbs: appendPoint(m_stringBuilder, segment.point1); appendPoint(m_stringBuilder, segment.targetPoint); break; case PathSegArcRel: case PathSegArcAbs: appendPoint(m_stringBuilder, segment.point1); appendFloat(m_stringBuilder, segment.point2.x()); appendBool(m_stringBuilder, segment.arcLarge); appendBool(m_stringBuilder, segment.arcSweep); appendPoint(m_stringBuilder, segment.targetPoint); break; default: ASSERT_NOT_REACHED(); } m_stringBuilder.append(' '); }
void BSONObjBuilder::appendMaxForType( const string& field , int t ){ switch ( t ){ case MinKey: appendMaxKey( field.c_str() ); break; case MaxKey: appendMaxKey( field.c_str() ); break; case NumberInt: case NumberDouble: case NumberLong: append( field.c_str() , numeric_limits<double>::max() ); break; case jstOID: { OID o; memset(&o, 0xFF, sizeof(o)); appendOID( field.c_str() , &o); break; } case Bool: appendBool( field.c_str() , true); break; case Date: appendDate( field.c_str() , 0xFFFFFFFFFFFFFFFFLL ); break; case String: append( field.c_str() , BSONObj() ); break; case Timestamp: append( field.c_str() , (long long)0 ); break; default: appendMinForType( field , t + 1 ); } }
void BSONObjBuilder::appendMaxForType( const string& field , int t ){ switch ( t ){ case MinKey: appendMaxKey( field.c_str() ); break; case MaxKey: appendMaxKey( field.c_str() ); break; case NumberInt: case NumberDouble: case NumberLong: append( field.c_str() , numeric_limits<double>::max() ); break; case BinData: appendMinForType( field , jstOID ); break; case jstOID: { OID o; memset(&o, 0xFF, sizeof(o)); appendOID( field.c_str() , &o); break; } case Undefined: case jstNULL: appendMinForType( field , NumberInt ); case Bool: appendBool( field.c_str() , true); break; case Date: appendDate( field.c_str() , 0xFFFFFFFFFFFFFFFFLL ); break; case Symbol: case String: append( field.c_str() , BSONObj() ); break; case Code: case CodeWScope: appendCodeWScope( field.c_str() , "ZZZ" , BSONObj() ); break; case Timestamp: appendTimestamp( field.c_str() , numeric_limits<unsigned long long>::max() ); break; default: appendMinForType( field , t + 1 ); } }
void SshOutgoingPacket::generateKeyExchangeInitPacket() { const QByteArray &supportedkeyExchangeMethods = encodeNameList(SshCapabilities::KeyExchangeMethods); const QByteArray &supportedPublicKeyAlgorithms = encodeNameList(SshCapabilities::PublicKeyAlgorithms); const QByteArray &supportedEncryptionAlgorithms = encodeNameList(SshCapabilities::EncryptionAlgorithms); const QByteArray &supportedMacAlgorithms = encodeNameList(SshCapabilities::MacAlgorithms); const QByteArray &supportedCompressionAlgorithms = encodeNameList(SshCapabilities::CompressionAlgorithms); const QByteArray &supportedLanguages = encodeNameList(QList<QByteArray>()); init(SSH_MSG_KEXINIT); m_data += m_encrypter.getRandomNumbers(16); m_data.append(supportedkeyExchangeMethods); m_data.append(supportedPublicKeyAlgorithms); m_data.append(supportedEncryptionAlgorithms) .append(supportedEncryptionAlgorithms); m_data.append(supportedMacAlgorithms).append(supportedMacAlgorithms); m_data.append(supportedCompressionAlgorithms) .append(supportedCompressionAlgorithms); m_data.append(supportedLanguages).append(supportedLanguages); appendBool(false); // No guessed packet. m_data.append(QByteArray(4, 0)); // Reserved. finalize(); }
QString JsonPin::toString(){ QString str; str="{\n"; str+=appendString("Id")+":"+appendNum(Id)+",\n"; str+=appendString("Name")+":"+appendString(Name)+",\n"; str+=appendString("Desc")+":"+appendString(Desc)+",\n"; str+=appendString("DataType")+":"+appendString(DataType)+",\n"; str+=appendString("InputPin")+":"+appendBool(InputPin); str+="\n}"; return str; }
void BSONObjBuilder::appendMaxForType( const StringData& fieldName , int t ) { switch ( t ) { // Shared canonical types case NumberInt: case NumberDouble: case NumberLong: append( fieldName , std::numeric_limits<double>::max() ); return; case Symbol: case String: appendMinForType( fieldName, Object ); return; case Date: appendDate( fieldName , std::numeric_limits<long long>::max() ); return; case Timestamp: // TODO integrate with Date SERVER-3304 append( fieldName , OpTime::max() ); return; case Undefined: // shared with EOO appendUndefined( fieldName ); return; // Separate canonical types case MinKey: appendMinKey( fieldName ); return; case MaxKey: appendMaxKey( fieldName ); return; case jstOID: { OID o = OID::max(); appendOID( fieldName , &o); return; } case Bool: appendBool( fieldName , true ); return; case jstNULL: appendNull( fieldName ); return; case Object: appendMinForType( fieldName, Array ); return; case Array: appendMinForType( fieldName, BinData ); return; case BinData: appendMinForType( fieldName, jstOID ); return; case RegEx: appendMinForType( fieldName, DBRef ); return; case DBRef: appendMinForType( fieldName, Code ); return; case Code: appendMinForType( fieldName, CodeWScope ); return; case CodeWScope: // This upper bound may change if a new bson type is added. appendMinForType( fieldName , MaxKey ); return; } log() << "type not supported for appendMaxElementForType: " << t; uassert( 14853 , "type not supported for appendMaxElementForType" , false ); }
void BSONObjBuilder::appendMinForType( const string& field , int t ){ switch ( t ){ case MinKey: appendMinKey( field.c_str() ); return; case MaxKey: appendMinKey( field.c_str() ); return; case NumberInt: case NumberDouble: case NumberLong: append( field.c_str() , - numeric_limits<double>::max() ); return; case jstOID: { OID o; memset(&o, 0, sizeof(o)); appendOID( field.c_str() , &o); return; } case Bool: appendBool( field.c_str() , false); return; case Date: appendDate( field.c_str() , 0); return; case jstNULL: appendNull( field.c_str() ); return; case String: append( field.c_str() , "" ); return; case Object: append( field.c_str() , BSONObj() ); return; case Array: appendArray( field.c_str() , BSONObj() ); return; case BinData: appendBinData( field.c_str() , 0 , Function , 0 ); return; case Undefined: appendUndefined( field.c_str() ); return; case RegEx: appendRegex( field.c_str() , "" ); return; case DBRef: { OID o; memset(&o, 0, sizeof(o)); appendDBRef( field.c_str() , "" , o ); return; } case Code: appendCode( field.c_str() , "" ); return; case Symbol: appendSymbol( field.c_str() , "" ); return; case CodeWScope: appendCodeWScope( field.c_str() , "" , BSONObj() ); return; case Timestamp: appendTimestamp( field.c_str() , 0); return; }; log() << "type not support for appendMinElementForType: " << t << endl; uassert( "type not supported for appendMinElementForType" , false ); }
static SkPDFIndirectReference make_function_shader(SkPDFDocument* doc, const SkPDFGradientShader::Key& state) { SkPoint transformPoints[2]; const SkShader::GradientInfo& info = state.fInfo; SkMatrix finalMatrix = state.fCanvasTransform; finalMatrix.preConcat(state.fShaderTransform); bool doStitchFunctions = (state.fType == SkShader::kLinear_GradientType || state.fType == SkShader::kRadial_GradientType || state.fType == SkShader::kConical_GradientType) && (SkTileMode)info.fTileMode == SkTileMode::kClamp && !finalMatrix.hasPerspective(); int32_t shadingType = 1; auto pdfShader = SkPDFMakeDict(); // The two point radial gradient further references // state.fInfo // in translating from x, y coordinates to the t parameter. So, we have // to transform the points and radii according to the calculated matrix. if (doStitchFunctions) { pdfShader->insertObject("Function", gradientStitchCode(info)); shadingType = (state.fType == SkShader::kLinear_GradientType) ? 2 : 3; auto extend = SkPDFMakeArray(); extend->reserve(2); extend->appendBool(true); extend->appendBool(true); pdfShader->insertObject("Extend", std::move(extend)); std::unique_ptr<SkPDFArray> coords; if (state.fType == SkShader::kConical_GradientType) { SkScalar r1 = info.fRadius[0]; SkScalar r2 = info.fRadius[1]; SkPoint pt1 = info.fPoint[0]; SkPoint pt2 = info.fPoint[1]; FixUpRadius(pt1, r1, pt2, r2); coords = SkPDFMakeArray(pt1.x(), pt1.y(), r1, pt2.x(), pt2.y(), r2); } else if (state.fType == SkShader::kRadial_GradientType) { const SkPoint& pt1 = info.fPoint[0]; coords = SkPDFMakeArray(pt1.x(), pt1.y(), 0, pt1.x(), pt1.y(), info.fRadius[0]); } else { const SkPoint& pt1 = info.fPoint[0]; const SkPoint& pt2 = info.fPoint[1]; coords = SkPDFMakeArray(pt1.x(), pt1.y(), pt2.x(), pt2.y()); } pdfShader->insertObject("Coords", std::move(coords)); } else { // Depending on the type of the gradient, we want to transform the // coordinate space in different ways. transformPoints[0] = info.fPoint[0]; transformPoints[1] = info.fPoint[1]; switch (state.fType) { case SkShader::kLinear_GradientType: break; case SkShader::kRadial_GradientType: transformPoints[1] = transformPoints[0]; transformPoints[1].fX += info.fRadius[0]; break; case SkShader::kConical_GradientType: { transformPoints[1] = transformPoints[0]; transformPoints[1].fX += SK_Scalar1; break; } case SkShader::kSweep_GradientType: transformPoints[1] = transformPoints[0]; transformPoints[1].fX += SK_Scalar1; break; case SkShader::kColor_GradientType: case SkShader::kNone_GradientType: default: return SkPDFIndirectReference(); } // Move any scaling (assuming a unit gradient) or translation // (and rotation for linear gradient), of the final gradient from // info.fPoints to the matrix (updating bbox appropriately). Now // the gradient can be drawn on on the unit segment. SkMatrix mapperMatrix; unit_to_points_matrix(transformPoints, &mapperMatrix); finalMatrix.preConcat(mapperMatrix); // Preserves as much as possible in the final matrix, and only removes // the perspective. The inverse of the perspective is stored in // perspectiveInverseOnly matrix and has 3 useful numbers // (p0, p1, p2), while everything else is either 0 or 1. // In this way the shader will handle it eficiently, with minimal code. SkMatrix perspectiveInverseOnly = SkMatrix::I(); if (finalMatrix.hasPerspective()) { if (!split_perspective(finalMatrix, &finalMatrix, &perspectiveInverseOnly)) { return SkPDFIndirectReference(); } } SkRect bbox; bbox.set(state.fBBox); if (!SkPDFUtils::InverseTransformBBox(finalMatrix, &bbox)) { return SkPDFIndirectReference(); } SkDynamicMemoryWStream functionCode; SkShader::GradientInfo infoCopy = info; if (state.fType == SkShader::kConical_GradientType) { SkMatrix inverseMapperMatrix; if (!mapperMatrix.invert(&inverseMapperMatrix)) { return SkPDFIndirectReference(); } inverseMapperMatrix.mapPoints(infoCopy.fPoint, 2); infoCopy.fRadius[0] = inverseMapperMatrix.mapRadius(info.fRadius[0]); infoCopy.fRadius[1] = inverseMapperMatrix.mapRadius(info.fRadius[1]); } switch (state.fType) { case SkShader::kLinear_GradientType: linearCode(infoCopy, perspectiveInverseOnly, &functionCode); break; case SkShader::kRadial_GradientType: radialCode(infoCopy, perspectiveInverseOnly, &functionCode); break; case SkShader::kConical_GradientType: twoPointConicalCode(infoCopy, perspectiveInverseOnly, &functionCode); break; case SkShader::kSweep_GradientType: sweepCode(infoCopy, perspectiveInverseOnly, &functionCode); break; default: SkASSERT(false); } pdfShader->insertObject( "Domain", SkPDFMakeArray(bbox.left(), bbox.right(), bbox.top(), bbox.bottom())); auto domain = SkPDFMakeArray(bbox.left(), bbox.right(), bbox.top(), bbox.bottom()); std::unique_ptr<SkPDFArray> rangeObject = SkPDFMakeArray(0, 1, 0, 1, 0, 1); pdfShader->insertRef("Function", make_ps_function(functionCode.detachAsStream(), std::move(domain), std::move(rangeObject), doc)); } pdfShader->insertInt("ShadingType", shadingType); pdfShader->insertName("ColorSpace", "DeviceRGB"); SkPDFDict pdfFunctionShader("Pattern"); pdfFunctionShader.insertInt("PatternType", 2); pdfFunctionShader.insertObject("Matrix", SkPDFUtils::MatrixToArray(finalMatrix)); pdfFunctionShader.insertObject("Shading", std::move(pdfShader)); return doc->emit(pdfFunctionShader); }
void deviceTimerHandleRawData(char commandHeader, InputStream* inputStream, OutputStream* outputStream) { if (commandHeader == COMMAND_TIMER_LIST) { printTimerList(getInfoOutputStreamLogger(), getTimerList()); ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_LIST); } else if (commandHeader == COMMAND_TIMER_COUNT) { ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_COUNT); unsigned timerCount = getTimerCount(); appendHex2(outputStream, timerCount); } else if (commandHeader == COMMAND_TIMER_READ) { ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_READ); unsigned char timerIndex = readHex2(inputStream); Timer* timer = getTimerByIndex(timerIndex); appendHex2(outputStream, timerIndex); appendSeparator(outputStream); appendHex2(outputStream, timer->timerCode); appendSeparator(outputStream); appendHex4(outputStream, timer->timeDiviser); appendSeparator(outputStream); appendHex4(outputStream, timer->timeInternalCounter); appendSeparator(outputStream); appendHex6(outputStream, timer->time); appendSeparator(outputStream); appendHex6(outputStream, timer->markTime); appendSeparator(outputStream); appendBool(outputStream, timer->enabled); } // Enable / Tisable else if (commandHeader == COMMAND_TIMER_ENABLE_DISABLE) { unsigned char timerIndex = readHex2(inputStream); Timer* timer = getTimerByIndex(timerIndex); checkIsSeparator(inputStream); unsigned enableAsChar = readHex(inputStream); bool enabled = enableAsChar != 0; timer->enabled = enabled; ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_ENABLE_DISABLE); } // Mark else if (commandHeader == COMMAND_TIMER_MARK) { unsigned char timerIndex = readHex2(inputStream); Timer* timer = getTimerByIndex(timerIndex); unsigned long time = markTimer(timer); ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_MARK); appendHex6(outputStream, time); } else if (commandHeader == COMMAND_TIMER_TIME_SINCE_LAST_MARK) { unsigned char timerIndex = readHex2(inputStream); Timer* timer = getTimerByIndex(timerIndex); unsigned long value = getTimeSinceLastMark(timer); ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_TIME_SINCE_LAST_MARK); appendHex6(outputStream, value); } else if (commandHeader == COMMAND_TIMER_TIMEOUT) { unsigned char timerIndex = readHex2(inputStream); checkIsSeparator(inputStream); unsigned long timeToCheck = (unsigned long) readHex6(inputStream); Timer* timer = getTimerByIndex(timerIndex); bool value = timeout(timer, timeToCheck); ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_TIMEOUT); appendHex2(outputStream, timerIndex); appendSeparator(outputStream); appendBool(outputStream, value); } // Demo else if (commandHeader == COMMAND_TIMER_DEMO) { Timer* timer = getTimerByCode(DEMO_TIMER_INDEX); if (timer == NULL) { timer = addTimerDemo(); } // Timer could be null when adding the timerDemo because of limit, we don't want any crash ! if (timer != NULL) { unsigned enableAsChar = readHex(inputStream); bool enabled = enableAsChar != 0; timer->enabled = enabled; } ackCommand(outputStream, TIMER_DEVICE_HEADER, COMMAND_TIMER_DEMO); } }