Beispiel #1
0
/*!
    \fn QString QOperatingSystemVersion::name() const

    Returns a string representation of the OS type identified by the QOperatingSystemVersion.

    \sa type()
*/
QString QOperatingSystemVersion::name() const
{
    switch (type()) {
    case QOperatingSystemVersion::Windows:
        return QStringLiteral("Windows");
    case QOperatingSystemVersion::MacOS: {
        if (majorVersion() < 10)
            return QStringLiteral("Mac OS");
        if (majorVersion() == 10 && minorVersion() < 8)
            return QStringLiteral("Mac OS X");
        if (majorVersion() == 10 && minorVersion() < 12)
            return QStringLiteral("OS X");
        return QStringLiteral("macOS");
    }
    case QOperatingSystemVersion::IOS: {
        if (majorVersion() < 4)
            return QStringLiteral("iPhone OS");
        return QStringLiteral("iOS");
    }
    case QOperatingSystemVersion::TvOS:
        return QStringLiteral("tvOS");
    case QOperatingSystemVersion::WatchOS:
        return QStringLiteral("watchOS");
    case QOperatingSystemVersion::Android:
        return QStringLiteral("Android");
    case QOperatingSystemVersion::Unknown:
    default:
        return QString();
    }
}
Beispiel #2
0
QString QgsPostgresConn::fieldExpression( const QgsField &fld )
{
  const QString &type = fld.typeName();
  if ( type == "money" )
  {
    return QString( "cash_out(%1)" ).arg( quotedIdentifier( fld.name() ) );
  }
  else if ( type.startsWith( "_" ) )
  {
    return QString( "array_out(%1)" ).arg( quotedIdentifier( fld.name() ) );
  }
  else if ( type == "bool" )
  {
    return QString( "boolout(%1)" ).arg( quotedIdentifier( fld.name() ) );
  }
  else if ( type == "geometry" )
  {
    return QString( "%1(%2)" )
           .arg( majorVersion() < 2 ? "asewkt" : "st_asewkt" )
           .arg( quotedIdentifier( fld.name() ) );
  }
  else if ( type == "geography" )
  {
    return QString( "st_astext(%1)" ).arg( quotedIdentifier( fld.name() ) );
  }
  else
  {
    return quotedIdentifier( fld.name() ) + "::text";
  }
}
Beispiel #3
0
static QString subsystemVersion(const QString &version)
{
    const auto v = Internal::Version::fromString(version);
    return QStringLiteral("%1.%2").arg(
                QString::number(v.majorVersion()),
                QString::number(v.minorVersion()).rightJustified(2, QLatin1Char('0')));
}
// Write virtual function overries used to decide on static/virtual calls
int  QHttpRequestHeader_QtDShell::__override_majorVersion(bool static_call) const
{
    if (static_call) {
        return QHttpRequestHeader::majorVersion();
    } else {
        return majorVersion();
    }
}
Beispiel #5
0
const std::string &versionString()
{
	static std::string v;
	if( !v.size() )
	{
		v = boost::str( boost::format( "%d.%d.%d" ) % majorVersion() % minorVersion() % patchVersion() );
	}
	return v;
}
Beispiel #6
0
bool VersionInfoInterface::isSameMajorVersion(const char* otherVersion) const noexcept {
    int major = -1, minor = -1;
    pcrecpp::RE ver_regex("^(\\d+)\\.(\\d+)\\.");
    ver_regex.PartialMatch(otherVersion, &major, &minor);

    if (major == -1 || minor == -1)
        return false;

    return (major == majorVersion() && minor == minorVersion());
}
Beispiel #7
0
bool Version::candidateGreaterThanCurrent(const VersionThing & candidateVersionThing)
{
	VersionThing myVersionThing;
	myVersionThing.majorVersion = majorVersion().toInt();
	myVersionThing.minorVersion = minorVersion().toInt();
	myVersionThing.minorSubVersion = minorSubVersion().toInt();
	myVersionThing.releaseModifier = modifier();

	return greaterThan(myVersionThing, candidateVersionThing); 
}
/*!
  Returns a byte array representation of the HTTP request header.
*/
QByteArray THttpRequestHeader::toByteArray() const
{
    QByteArray ba;
    ba += reqMethod + ' ' + reqUri + " HTTP/";
    ba += QByteArray::number(majorVersion());
    ba += '.';
    ba += QByteArray::number(minorVersion());
    ba += "\r\n";
    ba += THttpHeader::toByteArray();
    return ba;
}
Status onShardVersionMismatch(OperationContext* opCtx,
                              const NamespaceString& nss,
                              ChunkVersion shardVersionReceived,
                              bool forceRefreshFromThisThread) noexcept {
    invariant(!opCtx->lockState()->isLocked());
    invariant(!opCtx->getClient()->isInDirectClient());

    auto const shardingState = ShardingState::get(opCtx);
    invariant(shardingState->canAcceptShardedCommands());

    LOG(2) << "Metadata refresh requested for " << nss.ns() << " at shard version "
           << shardVersionReceived;

    ShardingStatistics::get(opCtx).countStaleConfigErrors.addAndFetch(1);

    // Ensure any ongoing migrations have completed before trying to do the refresh. This wait is
    // just an optimization so that MongoS does not exhaust its maximum number of StaleConfig retry
    // attempts while the migration is being committed.
    try {
        auto& oss = OperationShardingState::get(opCtx);
        oss.waitForMigrationCriticalSectionSignal(opCtx);
    } catch (const DBException& ex) {
        return ex.toStatus();
    }

    const auto currentShardVersion = [&] {
        AutoGetCollection autoColl(opCtx, nss, MODE_IS);
        const auto currentMetadata = CollectionShardingState::get(opCtx, nss)->getMetadata(opCtx);
        if (currentMetadata) {
            return currentMetadata->getShardVersion();
        }

        return ChunkVersion::UNSHARDED();
    }();

    if (currentShardVersion.epoch() == shardVersionReceived.epoch() &&
        currentShardVersion.majorVersion() >= shardVersionReceived.majorVersion()) {
        // Don't need to remotely reload if we're in the same epoch and the requested version is
        // smaller than the one we know about. This means that the remote side is behind.
        return Status::OK();
    }

    try {
        forceShardFilteringMetadataRefresh(opCtx, nss, forceRefreshFromThisThread);
        return Status::OK();
    } catch (const DBException& ex) {
        log() << "Failed to refresh metadata for collection" << nss << causedBy(redact(ex));
        return ex.toStatus();
    }
}
/*!
  Returns a byte array representation of the HTTP response header.
*/
QByteArray THttpResponseHeader::toByteArray() const
{
    QByteArray ba;
    ba += "HTTP/";
    ba += QByteArray::number(majorVersion());
    ba += '.';
    ba += QByteArray::number(minorVersion());
    ba += ' ';
    ba += QByteArray::number(statCode);
    ba += ' ';
    ba += reasonPhr;
    ba += "\r\n";
    ba += THttpHeader::toByteArray();
    return ba;
}
Beispiel #11
0
void VersionInfoInterface::appendBuildInfo(BSONObjBuilder* result) const {
    *result << "version" << version() << "gitVersion" << gitVersion()
#if defined(_WIN32)
            << "targetMinOS" << targetMinOS()
#endif
            << "modules" << modules() << "allocator" << allocator() << "javascriptEngine"
            << jsEngine() << "sysInfo"
            << "deprecated";

    BSONArrayBuilder versionArray(result->subarrayStart("versionArray"));
    versionArray << majorVersion() << minorVersion() << patchVersion() << extraVersion();
    versionArray.done();

    BSONObjBuilder opensslInfo(result->subobjStart("openssl"));
#ifdef MONGO_CONFIG_SSL
#if MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_OPENSSL
    opensslInfo << "running" << openSSLVersion() << "compiled" << OPENSSL_VERSION_TEXT;
#elif MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_WINDOWS
    opensslInfo << "running"
                << "Windows SChannel";
#elif MONGO_CONFIG_SSL_PROVIDER == MONGO_CONFIG_SSL_PROVIDER_APPLE
    opensslInfo << "running"
                << "Apple Secure Transport";
#else
#error "Unknown SSL Provider"
#endif  // MONGO_CONFIG_SSL_PROVIDER
#else
    opensslInfo << "running"
                << "disabled"
                << "compiled"
                << "disabled";
#endif
    opensslInfo.done();

    BSONObjBuilder buildvarsInfo(result->subobjStart("buildEnvironment"));
    for (auto&& envDataEntry : buildInfo()) {
        if (std::get<2>(envDataEntry)) {
            buildvarsInfo << std::get<0>(envDataEntry) << std::get<1>(envDataEntry);
        }
    }
    buildvarsInfo.done();

    *result << "bits" << (int)sizeof(void*) * 8;
    result->appendBool("debug", kDebugBuild);
    result->appendNumber("maxBsonObjectSize", BSONObjMaxUserSize);
}
Beispiel #12
0
//-------------------------------------------------------------------------------------------------
bool GlesBox::bindEGLContext(uint32_t width, uint32_t height, uint64_t native_windows_id) {
  if (core_->display_ == nullptr) {
    // Get Display
    core_->display_ = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    if (core_->display_ == EGL_NO_DISPLAY) {
      LOGE("Cann't get EGL display on native windows.");
      return false;
    }

    // Initialize EGL
    EGLint majorVersion(0), minorVersion(0);
    if (!eglInitialize(core_->display_, &majorVersion, &minorVersion)) {
      LOGE("Cann't eglInitialize EGL display.");
      return false;
    }
    eglBindAPI(EGL_OPENGL_ES_API);

    // Get configs
    EGLint numConfigs(0);
    if (!eglGetConfigs(core_->display_, NULL, 0, &numConfigs)) {
      LOGE("eglGetConfigs fail.");
      return false;
    }

    // Choose config
    EGLint attribList[] = {
      EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
		  EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
      EGL_RED_SIZE, 8,
      EGL_GREEN_SIZE, 8,
      EGL_BLUE_SIZE, 8,
      EGL_ALPHA_SIZE, 8,
      EGL_NONE
    };
    if (!eglChooseConfig(core_->display_, attribList, &core_->config_, 1, &numConfigs)) {
      LOGE("eglChooseConfig fail.");
      return false;
    }

    createSurface(width, height, native_windows_id);
    // Create a GL context
    EGLint contextAttribs[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE, EGL_NONE};
    core_->context_ = 
      eglCreateContext(core_->display_, core_->config_, EGL_NO_CONTEXT, contextAttribs);
    if (core_->context_ == EGL_NO_CONTEXT) {
      LOGE("eglCreateContext fail.");
      return false;
    }
  }

  //renew a surface because of size changed
  if (core_->width_ != width || core_->height_ != height) {
    createSurface(width, height, native_windows_id);
  }

  // Make the context current
  if ( !eglMakeCurrent(core_->display_, core_->surface_, core_->surface_, core_->context_) ) {
    LOGE("eglMakeCurrent fail.");
    return false;
  }

  return true;
}
Beispiel #13
0
Version query::version()
{
	return Version(majorVersion(), minorVersion());
}
Beispiel #14
0
void QgsPostgresConn::retrieveLayerTypes( QgsPostgresLayerProperty &layerProperty, bool useEstimatedMetadata )
{
  QString table;

  if ( !layerProperty.schemaName.isEmpty() )
  {
    table = QString( "%1.%2" )
            .arg( quotedIdentifier( layerProperty.schemaName ) )
            .arg( quotedIdentifier( layerProperty.tableName ) );
  }
  else
  {
    // Query
    table = layerProperty.tableName;
  }


  // our estimatation ignores that a where clause might restrict the feature type or srid
  if ( useEstimatedMetadata )
  {
    table = QString( "(SELECT %1 FROM %2 WHERE %1 IS NOT NULL%3 LIMIT %4) AS t" )
            .arg( quotedIdentifier( layerProperty.geometryColName ) )
            .arg( table )
            .arg( layerProperty.sql.isEmpty() ? "" : QString( " AND (%1)" ).arg( layerProperty.sql ) )
            .arg( sGeomTypeSelectLimit );
  }
  else if ( !layerProperty.sql.isEmpty() )
  {
    table += QString( " WHERE %1" ).arg( layerProperty.sql );
  }

  QString query = QString( "SELECT DISTINCT"
                           " CASE"
                           " WHEN %1 THEN 'POINT'"
                           " WHEN %2 THEN 'LINESTRING'"
                           " WHEN %3 THEN 'POLYGON'"
                           " END,"
                           " %4(%5%6)"
                           " FROM %7" )
                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::WKBPoint, layerProperty.geometryColType == sctGeography ) )
                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::WKBLineString, layerProperty.geometryColType == sctGeography ) )
                  .arg( postgisTypeFilter( layerProperty.geometryColName, QGis::WKBPolygon, layerProperty.geometryColType == sctGeography ) )
                  .arg( majorVersion() < 2 ? "srid" : "st_srid" )
                  .arg( quotedIdentifier( layerProperty.geometryColName ) )
                  .arg( layerProperty.geometryColType == sctGeography ? "::geometry" : "" )
                  .arg( table );

  QgsDebugMsg( "Retrieving geometry types: " + query );

  QgsPostgresResult gresult = PQexec( query );

  QString type;
  QString srid;
  if ( gresult.PQresultStatus() == PGRES_TUPLES_OK )
  {
    QStringList types;
    QStringList srids;

    for ( int i = 0; i < gresult.PQntuples(); i++ )
    {
      QString type = gresult.PQgetvalue( i, 0 );
      QString srid = gresult.PQgetvalue( i, 1 );
      if ( type.isEmpty() )
        continue;

      types << type;
      srids << srid;
    }

    type = types.join( "," );
    srid = srids.join( "," );
  }

  QgsDebugMsg( QString( "type:%1 srid:%2" ).arg( type ).arg( srid ) );
  layerProperty.type = type;
  layerProperty.srid = srid;
}
void OpenGLWidget::initializeGL() {
    // Initialize Qt's OpenGL functions.
    initializeOpenGLFunctions();
    auto format = QOpenGLContext::currentContext()->format();
    printf("OpenGL: version %d.%d\n", format.majorVersion(), format.minorVersion());

    // General OpenGL settings.
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_NONE);

    // Set color to clear window (black).
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

    // Prepare shader.
    shader = std::make_unique<QOpenGLShaderProgram>(this);
    shader->addShaderFromSourceFile(QOpenGLShader::Vertex,
        QString(SHADER_DIRECTORY) + "render.vert");
    shader->addShaderFromSourceFile(QOpenGLShader::Fragment,
        QString(SHADER_DIRECTORY) + "render.frag");
    shader->link();
    if (!shader->isLinked()) {
        std::cerr << "Failed to build shaders!" << std::endl;
        std::exit(1);
    }

    // Load OBJ.
    const std::string filename = std::string(DATA_DIRECTORY) + "plane.obj";
    std::vector<tinyobj::shape_t> shapes;
    std::vector<tinyobj::material_t> materials;
    tinyobj::attrib_t attrib;
    std::string err;
    bool success = tinyobj::LoadObj(&attrib, &shapes, &materials, &err, filename.c_str());
    if (!err.empty()) {
        std::cerr << err << std::endl;
    }
    
    if (!success) {
        std::exit(1);
    }

    std::vector<Vertex> vertices;
    std::vector<uint32_t> indices;
    for (const auto &s : shapes) {
        for (const auto &index : s.mesh.indices) {
            const int posIndex = index.vertex_index;
            QVector3D position;
            if (posIndex >= 0) {
                position = {
                    attrib.vertices[posIndex * 3 + 0],
                    attrib.vertices[posIndex * 3 + 1],
                    attrib.vertices[posIndex * 3 + 2]
                };
            }

            const int normIndex = index.normal_index;
            QVector3D normal;
            if (normIndex >= 0) {
                normal = {
                    attrib.normals[normIndex * 3 + 0],
                    attrib.normals[normIndex * 3 + 1],
                    attrib.normals[normIndex * 3 + 2]
                };
            }

            const int uvIndex = index.texcoord_index;
            QVector2D texcoord;
            if (uvIndex >= 0) {
                texcoord = {
                    attrib.texcoords[uvIndex * 2 + 0],
                    attrib.texcoords[uvIndex * 2 + 1]
                };
            }

            indices.push_back(vertices.size());
            vertices.emplace_back(position, normal, texcoord);
        }
    }

    // Prepare VAO.
    vao = std::make_unique<QOpenGLVertexArrayObject>(this);
    vao->create();
    vao->bind();

    vbo = std::make_unique<QOpenGLBuffer>(QOpenGLBuffer::VertexBuffer);
    vbo->create();
    vbo->setUsagePattern(QOpenGLBuffer::StaticDraw);
    vbo->bind();
    vbo->allocate(vertices.data(), sizeof(Vertex) * vertices.size());
    
    glEnableVertexAttribArray(POSITION_LAYOUT_LOC);
    glVertexAttribPointer(POSITION_LAYOUT_LOC, 3, GL_FLOAT, GL_FALSE,
        sizeof(Vertex), (void *)offsetof(Vertex, position));

    glEnableVertexAttribArray(NORMAL_LAYOUT_LOC);
    glVertexAttribPointer(NORMAL_LAYOUT_LOC, 3, GL_FLOAT, GL_FALSE,
        sizeof(Vertex), (void *)offsetof(Vertex, normal));

    glEnableVertexAttribArray(TEXCOORD_LAYOUT_LOC);
    glVertexAttribPointer(TEXCOORD_LAYOUT_LOC, 2, GL_FLOAT, GL_FALSE,
        sizeof(Vertex), (void *)offsetof(Vertex, texcoord));

    ibo = std::make_unique<QOpenGLBuffer>(QOpenGLBuffer::IndexBuffer);
    ibo->create();
    ibo->setUsagePattern(QOpenGLBuffer::StaticDraw);
    ibo->bind();
    ibo->allocate(indices.data(), sizeof(uint32_t) * indices.size());

    vao->release();
    
    // Prepare texture.
    const QString imgfile = QString(DATA_DIRECTORY) + "lena.png";
    QImage teximage;
    teximage.load(imgfile);
    if (teximage.isNull()) {
        std::cerr << "Failed to load image: " << imgfile.toStdString() << std::endl;
    }
    
    texture = std::make_unique<QOpenGLTexture>(teximage, QOpenGLTexture::GenerateMipMaps);
}
Beispiel #16
0
Compatibility Reader::open()
{
	if(!_file->isOpen()) {
		if(!_file->open(QFile::ReadOnly)) {
			return CANNOT_READ;
		}
	}

	// Read magic bytes "DPRECR\0" or "DPRECH\0"
	char buf[7];
	if(_file->read(buf, 7) != 7)
		return CANNOT_READ;

	if(memcmp(buf, "DPRECR", 7)) {
		if(memcmp(buf, "DPRECH", 7))
			return NOT_DPREC;
		_isHibernation = true;
	}

	// Read protocol version
	if(_file->read(buf, 4) != 4)
		return NOT_DPREC;
	_formatversion = qFromBigEndian<quint32>((const uchar*)buf);

	// Read program version
	QByteArray progver;
	do {
		if(_file->read(buf, 1) != 1)
			return NOT_DPREC;
		progver.append(buf[0]);
	} while(buf[0] != '\0');
	_writerversion = QString::fromUtf8(progver);

	// If this is a hibernation file, read the rest of the header
	if(_isHibernation) {
		// We already read the protocol minor version
		_hibheader.minorVersion = minorVersion(_formatversion);

		// Check hibernation file format version
		char fmtver;
		if(!_file->getChar(&fmtver))
			return NOT_DPREC;

		// Currently there is only one format and no forward compatibility
		if((uchar)fmtver != 1)
			return INCOMPATIBLE;

		// Read session title
		if(_file->read(buf, 2) != 2)
			return NOT_DPREC;

		quint16 titleLen = qFromBigEndian<quint16>((const uchar*)buf);
		QByteArray title = _file->read(titleLen);
		if(title.length() != titleLen)
			return NOT_DPREC;

		_hibheader.title = QString::fromUtf8(title);

		// Read session founder name
		if(_file->read(buf, 1) != 1)
				return NOT_DPREC;
		quint8 founderLen = *buf;

		QByteArray founder = _file->read(founderLen);
		if(founder.length() != founderLen)
			return NOT_DPREC;

		_hibheader.founder = QString::fromUtf8(founder);

		// Read session flags
		char flags;
		if(!_file->getChar(&flags))
			return NOT_DPREC;
		_hibheader.flags = HibernationHeader::Flags((uchar)flags);

		// Read session password
		if(_file->read(buf, 2) != 2)
			return NOT_DPREC;

		quint16 passwdLen = qFromBigEndian<quint16>((const uchar*)buf);
		_hibheader.password = _file->read(passwdLen);
		if(_hibheader.password.length() != passwdLen)
			return NOT_DPREC;
	}

	_beginning = _file->pos();

	if(_isHibernation) {
		// Compatibility check is simple for hibernation files: we only need to look at the major version
		if(DRAWPILE_PROTO_MAJOR_VERSION == majorVersion(_formatversion))
			return COMPATIBLE;
		else
			return INCOMPATIBLE;

	} else {
		// Compatability check for normal recordings
		const quint32 myversion = version32(DRAWPILE_PROTO_MAJOR_VERSION, DRAWPILE_PROTO_MINOR_VERSION);

		// Best case: exact version match
		if(myversion == _formatversion)
			return COMPATIBLE;

		// A recording made with a newer (major) version may contain unsupported commands.
		if(majorVersion(myversion) < majorVersion(_formatversion))
			return UNKNOWN_COMPATIBILITY;

		// Newer minor version: expect rendering differences
		if(myversion < _formatversion)
			return MINOR_INCOMPATIBILITY;

		// Old versions known to be compatible
		switch(_formatversion) {
			case version32(11, 3): // we have compatibility code for these versions
			case version32(11, 2):
				return COMPATIBLE;
		}

		// Other versions are not supported
		return INCOMPATIBLE;
	}
}
int DhQHttpRequestHeader::DvhmajorVersion() const {
  return majorVersion();
}
Beispiel #18
0
	//
	//	SUMMARY: 拡張取得プロパティ系メソッド
	//
	KTL_INLINE NativeOSVersion::flag_type NativeOSVersion::versionFlag() {
		return majorVersion() * 0x100 + minorVersion();
	}
int DhQHttpResponseHeader::DvhmajorVersion() const {
  return majorVersion();
}
/*!
  \brief Returns meta information for a property. An invalid PropertyMetaInfo object if the given property name is unknown.

  \throws InvalidMetaInfoException if the object is not valid
  */
PropertyMetaInfo NodeMetaInfo::property(const QString &propertyName, bool resolveDotSyntax) const
{
    if (!isValid()) {
        qWarning() << "NodeMetaInfo is invalid";
        return PropertyMetaInfo();
    }

    if (resolveDotSyntax && propertyName.contains('.')) {
        const QStringList nameParts = propertyName.split('.');
        NodeMetaInfo nodeInfo = *this;
        const int partCount = nameParts.size();
        for (int i = 0; i < partCount; ++i) {
            const QString namePart(nameParts.at(i));
            const PropertyMetaInfo propInfo = nodeInfo.property(namePart, false);

            if (!propInfo.isValid())
                break;

            if (i + 1 == partCount)
                return propInfo;

            QString propertyType = propInfo.type();
            if (propertyType.right(1) == "*")
                propertyType = propertyType.left(propertyType.size() - 1).trimmed();
            nodeInfo = m_data->metaInfo.nodeMetaInfo(m_data->metaInfo.fromQtTypes(propertyType), majorVersion(), minorVersion());
            if (!nodeInfo.isValid()) {
                qWarning() << "no type info available for" << propertyType;
                break;
            }
        }

        return PropertyMetaInfo();
    } else {
        PropertyMetaInfo propertyMetaInfo;

        if (hasLocalProperty(propertyName)) {
            propertyMetaInfo = m_data->propertyMetaInfoHash.value(propertyName, PropertyMetaInfo());
        } else {
            foreach (const NodeMetaInfo &superTypeMetaInfo, superClasses()) {
                Q_ASSERT(superTypeMetaInfo.isValid());
                propertyMetaInfo = superTypeMetaInfo.property(propertyName);
                if (propertyMetaInfo.isValid())
                    break;
            }
        }

        return propertyMetaInfo;
    }
/*!
  \brief Returns meta information for all dot properties, including properties inherited from base types.

  */
QHash<QString,PropertyMetaInfo> NodeMetaInfo::dotProperties() const
{
    if (!isValid()) {
        qWarning() << "NodeMetaInfo is invalid";
        return QHash<QString,PropertyMetaInfo>();
    }

    QHash<QString,PropertyMetaInfo> propertiesInfo;

    foreach (const QString &propertyName, properties().keys()) {
        if (property(propertyName).hasDotSubProperties()) {
            QString propertyType = property(propertyName).type();
            if (propertyType.right(1) == "*")
                propertyType = propertyType.left(propertyType.size() - 1).trimmed();

            NodeMetaInfo nodeInfo(m_data->metaInfo.nodeMetaInfo(m_data->metaInfo.fromQtTypes(propertyType), majorVersion(), minorVersion()));
            if (nodeInfo.isValid()) {
                QHashIterator<QString,PropertyMetaInfo> iter(nodeInfo.properties());
                while (iter.hasNext()) {
                    iter.next();
                    if (!propertiesInfo.contains(iter.key()) && iter.key() != "objectName")
                        propertiesInfo.insert(propertyName + '.' + iter.key(), iter.value());
                }
            }
        }
    }
    return propertiesInfo;
}
Beispiel #22
0
inline
bool DeviceInfo::supports(FeatureSet feature_set) const
{
    int version = majorVersion() * 10 + minorVersion();
    return version >= feature_set;
}
void CollectionShardingState::checkShardVersionOrThrow(OperationContext* opCtx) {
    const auto optReceivedShardVersion = getOperationReceivedVersion(opCtx, _nss);

    if (!optReceivedShardVersion)
        return;

    const auto& receivedShardVersion = *optReceivedShardVersion;
    if (ChunkVersion::isIgnoredVersion(receivedShardVersion)) {
        return;
    }

    // An operation with read concern 'available' should never have shardVersion set.
    invariant(repl::ReadConcernArgs::get(opCtx).getLevel() !=
              repl::ReadConcernLevel::kAvailableReadConcern);

    const auto metadata = getCurrentMetadata();
    const auto wantedShardVersion =
        metadata->isSharded() ? metadata->getShardVersion() : ChunkVersion::UNSHARDED();

    auto criticalSectionSignal = [&] {
        auto csrLock = CSRLock::lock(opCtx, this);
        return _critSec.getSignal(opCtx->lockState()->isWriteLocked()
                                      ? ShardingMigrationCriticalSection::kWrite
                                      : ShardingMigrationCriticalSection::kRead);
    }();

    if (criticalSectionSignal) {
        // Set migration critical section on operation sharding state: operation will wait for the
        // migration to finish before returning failure and retrying.
        auto& oss = OperationShardingState::get(opCtx);
        oss.setMigrationCriticalSectionSignal(criticalSectionSignal);

        uasserted(StaleConfigInfo(_nss, receivedShardVersion, wantedShardVersion),
                  str::stream() << "migration commit in progress for " << _nss.ns());
    }

    if (receivedShardVersion.isWriteCompatibleWith(wantedShardVersion)) {
        return;
    }

    //
    // Figure out exactly why not compatible, send appropriate error message
    // The versions themselves are returned in the error, so not needed in messages here
    //

    StaleConfigInfo sci(_nss, receivedShardVersion, wantedShardVersion);

    uassert(std::move(sci),
            str::stream() << "epoch mismatch detected for " << _nss.ns() << ", "
                          << "the collection may have been dropped and recreated",
            wantedShardVersion.epoch() == receivedShardVersion.epoch());

    if (!wantedShardVersion.isSet() && receivedShardVersion.isSet()) {
        uasserted(std::move(sci),
                  str::stream() << "this shard no longer contains chunks for " << _nss.ns() << ", "
                                << "the collection may have been dropped");
    }

    if (wantedShardVersion.isSet() && !receivedShardVersion.isSet()) {
        uasserted(std::move(sci),
                  str::stream() << "this shard contains chunks for " << _nss.ns() << ", "
                                << "but the client expects unsharded collection");
    }

    if (wantedShardVersion.majorVersion() != receivedShardVersion.majorVersion()) {
        // Could be > or < - wanted is > if this is the source of a migration, wanted < if this is
        // the target of a migration
        uasserted(std::move(sci), str::stream() << "version mismatch detected for " << _nss.ns());
    }

    // Those are all the reasons the versions can mismatch
    MONGO_UNREACHABLE;
}