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;
   }

OfonoModemInterface::OfonoModemInterface(OfonoModem::SelectionSetting modemSetting, const QString& modemPath, const QString& ifname, OfonoGetPropertySetting propertySetting, QObject *parent)
    : QObject(parent)
{

    m_m = new OfonoModem(modemSetting, modemPath, this);
    connect(m_m, SIGNAL(validityChanged(bool)), this, SLOT(modemValidityChanged(bool)));
    connect(m_m, SIGNAL(interfacesChanged(QStringList)), this, SLOT(interfacesChanged(QStringList)));

    m_if = new OfonoInterface(m_m->path(), ifname, propertySetting, this);
    connect(m_m, SIGNAL(pathChanged(QString)), m_if, SLOT(setPath(const QString&)));
    m_isValid = checkValidity();
}

void ExportDissectionDialog::exportTypeChanged(QString name_filter)
{
    export_type_ = export_type_map_.value(name_filter);
    if (export_type_ == export_type_text) {
        packet_format_group_box_.setEnabled(true);
        print_args_.format = PR_FMT_TEXT;
    } else {
        packet_format_group_box_.setEnabled(false);
    }

    checkValidity();
}

/** Checks whether the signature appears valid */
NotTEC
preflight2 (PreflightContext const& ctx)
{
    auto const sigValid = checkValidity(ctx.app.getHashRouter(),
        ctx.tx, ctx.rules, ctx.app.config());
    if (sigValid.first == Validity::SigBad)
    {
        JLOG(ctx.j.debug()) <<
            "preflight2: bad signature. " << sigValid.second;
        return temINVALID;
    }
    return tesSUCCESS;
}

/** Constructor, sets the vertex attributes in a specific order */
VertexAttributes::VertexAttributes(const VertexAttribute* attributes, int attributesLength) 
{
	if (attributesLength < 1) 
		throw GdxRuntimeException("attributes must be >= 1");
	m_attributesLength = attributesLength;
	m_attributes = new VertexAttribute[attributesLength];

	for (int i = 0; i < attributesLength; i++)
		m_attributes[i] = attributes[i];

	checkValidity();
	m_vertexSize = calculateOffsets();
}

 void add(QWidget *w, QValidator *v) {
    Q_ASSERT(hasParent(v, w));
    auto prop = w->metaObject()->userProperty();
    auto propChanged = prop.notifySignal();
    static auto check = metaObject()->method(metaObject()->indexOfSlot("checkWidget()"));
    Q_ASSERT(check.isValid());
    if (!prop.isValid() || !propChanged.isValid())
       return qWarning("DialogValidator::add: The target widget has no user property with a notifier.");
    if (connect(w, propChanged, this, check)) {
       m_needsValid++;
       checkValidity(w);
    }
 }