C++ checkValidity函数代码示例

QList<QUrl> KURLListRequester::urlList()
{
    QList<QUrl> urls;

    QString text = urlLineEdit->text().simplified();
    if (!text.isEmpty()) {
        QString error;
        emit checkValidity(text, error);
        if (error.isNull())
            urls.append(QUrl::fromUserInput(text, QString(), QUrl::AssumeLocalFile));
    }

    for (int i = 0; i != urlListBox->count(); i++) {
        QListWidgetItem *item = urlListBox->item(i);

        QString text = item->text().simplified();

        QString error;
        emit checkValidity(text, error);
        if (error.isNull())
            urls.append(QUrl::fromUserInput(text, QString(), QUrl::AssumeLocalFile));
    }

    return urls;
}

LuaObjectBase* LuaObjectBase::getFromObject(lua_State* state, int object, bool error)
{
#ifdef FULL_USER_DATA
	// Make sure it's some user data!
	LUA->ReferencePush(object);
	int type = LUA->GetType(-1);
	if(type != GarrysMod::Lua::Type::USERDATA && type <= GarrysMod::Lua::Type::COUNT)
	{
		if (error)
		{
			LUA->ThrowError( "Invalid object! (not userdata)\n" );
		}
		return 0;
	}

	// Check the object
	GarrysMod::Lua::UserData* a = (GarrysMod::Lua::UserData*)LUA->GetUserdata(-1);
	LuaObjectBase* data = (LuaObjectBase*)(a->data);
	if (!checkValidity(state, type, data, error))
		return 0;
	
	// Just a simple cast required
	return reinterpret_cast<LuaObjectBase*>(a);
#else
	void* userData = object->GetMemberUserDataLite("_this");

	if (!checkValidity(luaInterface, 0, (LuaObjectBase*)userData, error))
		return 0;

	LuaObjectBase* baseObject = reinterpret_cast<LuaObjectBase*>(userData);
	baseObject->luaRef(object);
	return baseObject;
#endif
}

void OfonoModemInterface::updateValidity()
{
    if (isValid() != checkValidity()) {
        m_isValid = checkValidity();
        emit validityChanged(isValid());
    }
}

void eLSystem::evaluate() {
#if defined(eEDITOR)
	// check lsystem for regularity
	if( (!checkValidity(this->axiom)) ||
		(!checkValidity(this->grammar)))
		return;
#endif
	this->evaluate(*this->getDefaultState(1.0f));
}

EnergyCut::EnergyCut( const double lowerValue, const double upperValue ) :
    type_(Range),
    lowerValue_(lowerValue),
    upperValue_(upperValue)
{
  checkValidity();
}

bool LuaObjectBase::checkValidity(lua_State* state, int position, bool error)
{
#ifdef FULL_USER_DATA
// Make sure it's some user data!
	int type = LUA->GetType(position);
	if(type != GarrysMod::Lua::Type::USERDATA && type <= GarrysMod::Lua::Type::COUNT)
	{
		if (error)
		{
			LUA->ThrowError( "Invalid object! (not userdata)\n" );
		}
		return 0;
	}

// Acually do the check
	GarrysMod::Lua::UserData*  obj = (GarrysMod::Lua::UserData*)LUA->GetUserdata(position);
	LuaObjectBase* object = (LuaObjectBase*)(obj->data);
#else
	ILuaObject* table = luaInterface->GetObject(position);
	if (!table)
		return 0;

	LuaObjectBase* object = reinterpret_cast<LuaObjectBase*>( table->GetMemberUserDataLite("_this") );
	int type = 0;

	table->UnReference();
#endif

	return checkValidity(state, type, object, error);
}

Launcher::SongIterator Launcher::SongIterator::operator++(){
	do{
		iter++;
	}while(iter != boost::filesystem::directory_iterator() && !checkValidity());

	return *this;
}

ompl::base::PlannerStatus ompl::geometric::CForest::solve(const base::PlannerTerminationCondition &ptc)
{
    using solveFunctionType = void (ompl::geometric::CForest::*)(base::Planner *, const base::PlannerTerminationCondition &);

    checkValidity();

    time::point start = time::now();
    std::vector<std::thread*> threads(planners_.size());
    const base::ReportIntermediateSolutionFn prevSolutionCallback = getProblemDefinition()->getIntermediateSolutionCallback();

    if (prevSolutionCallback)
        OMPL_WARN("Cannot use previously set intermediate solution callback with %s", getName().c_str());

    pdef_->setIntermediateSolutionCallback(std::bind(&CForest::newSolutionFound, this,
        std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
    bestCost_ = opt_->infiniteCost();

    // run each planner in its own thread, with the same ptc.
    for (std::size_t i = 0 ; i < threads.size() ; ++i)
        threads[i] = new std::thread(std::bind((solveFunctionType)&CForest::solve, this, planners_[i].get(), ptc));

    for (auto & thread : threads)
    {
        thread->join();
        delete thread;
    }

    // restore callback
    getProblemDefinition()->setIntermediateSolutionCallback(prevSolutionCallback);
    OMPL_INFORM("Solution found in %f seconds", time::seconds(time::now() - start));
    return base::PlannerStatus(pdef_->hasSolution(), pdef_->hasApproximateSolution());
}

 BasicArrayFS<T, ARRAY_TYPE>::BasicArrayFS(lowlevel::TyFS anFS, uima::CAS & rFSSystem, bool bDoChecks) :
     FeatureStructure(anFS, rFSSystem) {
   if (bDoChecks) {
     checkValidity(UIMA_MSG_ID_EXCON_CREATING_ARRAYFS);
     checkArray(ARRAY_TYPE, iv_tyFS, iv_cas->getHeap(), UIMA_MSG_ID_EXCON_CREATING_ARRAYFS);
   }
 }

bool
SpArcSParameters::isValid()
{
    if (isValid_ == 0)
    {
        return false;
    }
    else if (isValid_ == 1)
    {
        return true;
    }
    else // isValid_ == -1
    {
        init();

        if (checkValidity())
        {
            isValid_ = 1;
            return true;
        }
        else
        {
            isValid_ = 0;
            return false;
        }
    }
}

  void BasicArrayFS<T, ARRAY_TYPE>::copyToArray(
    size_t uiStart,
    size_t uiEnd,
    T* destArray,
    size_t uiDestOffset) const {
      checkValidity(UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY);
      checkArraySize(iv_tyFS, iv_cas->getHeap(), uiEnd - uiStart - 1 , UIMA_MSG_ID_EXCON_GETTING_FS_FROM_ARRAY);
      uima::lowlevel::TyFSType typecode = iv_cas->getHeap()->getType(iv_tyFS);

	  size_t srcOffset = uiStart;
	  size_t numelements = uiEnd-uiStart;
	  size_t destOffset = uiDestOffset;

	  if (typecode== uima::internal::gs_tyIntArrayType || 
		  typecode== uima::internal::gs_tyFloatArrayType   ) {
			  iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(uima::lowlevel::TyHeapCell*) destArray,destOffset,numelements);
	  } else if(typecode== uima::internal::gs_tyByteArrayType || 
		        typecode== uima::internal::gs_tyBooleanArrayType) {
		  iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(char*) destArray,destOffset,numelements);
	  } else if(typecode== uima::internal::gs_tyShortArrayType ) {
		  iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(short*) destArray,destOffset,numelements);
      } else if(typecode== uima::internal::gs_tyLongArrayType || 
		        typecode== uima::internal::gs_tyDoubleArrayType) {
		  iv_cas->getHeap()->copyToArray( srcOffset,iv_tyFS,(INT64*) destArray,destOffset,numelements);
      } else {
      assertWithMsg(false, "Not yet implemented");
      UIMA_EXC_THROW_NEW(NotYetImplementedException,
                 UIMA_ERR_NOT_YET_IMPLEMENTED,
                 UIMA_MSG_ID_EXC_NOT_YET_IMPLEMENTED,
                 ErrorMessage(UIMA_MSG_ID_EXCON_UNKNOWN_CONTEXT),
                 ErrorInfo::unrecoverable
                );
      }
  }

void MySQLPreparedStatement::setInt64(const uint8 index, const int64 value)
{
    checkValidity(index);
    paramsSet[index - 1] = true;
    MYSQL_BIND * param = &bind[index-1];
    param->buffer_type    = MYSQL_TYPE_LONGLONG;
    setValue(param,&value,8);
}

bool KML::isValid()
{
    checkValidity();

    if( validity == KML_VALIDITY_VALID )
        CPLDebug("KML", "Valid: %d Version: %s", 
                 validity == KML_VALIDITY_VALID, sVersion_.c_str());

    return validity == KML_VALIDITY_VALID;
}

	IO::Flow ScanPhotoDirectory::onBeginFolder(
		const String& completePath,
		const String&, const String& /*name*/)
	{
		// I can't directly rule out the entire folder by a flowSkip, as this
		// invalid folder may include perfectly valid subfolders...
		pIsValidFolder = checkValidity(completePath);

		return IO::flowContinue;
	}

 bool isValid()  const
   { 
     if (checkValidity())
       try
         {
           return access(id_).isValid();
         }
       catch (error::Invalid&) {}
       
     return false;
   }