FXImage * MFXImageHelper::loadImage(FXApp *a, const std::string& file) { FXString ext=FXPath::extension(file.c_str()); checkSupported(ext); FXImage *img=NULL; if (comparecase(ext,"gif")==0) { img=new FXGIFImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"bmp")==0) { img=new FXBMPImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"xpm")==0) { img=new FXXPMImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"pcx")==0) { img=new FXPCXImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"ico")==0 || comparecase(ext,"cur")==0) { img=new FXICOImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"tga")==0) { img=new FXTGAImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"rgb")==0) { img=new FXRGBImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"xbm")==0) { img=new FXXBMImage(a,NULL,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"png")==0) { img=new FXPNGImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"jpg")==0 || comparecase(ext,"jpeg")==0) { img=new FXJPGImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else if (comparecase(ext,"tif")==0 || comparecase(ext,"tiff")==0) { img=new FXTIFImage(a,NULL,IMAGE_KEEP|IMAGE_SHMI|IMAGE_SHMP); } else { throw InvalidArgument("Unknown file extension for image '" + file + "'!"); } FXFileStream stream; if (img != NULL && stream.open(file.c_str(), FXStreamLoad)) { a->beginWaitCursor(); img->loadPixels(stream); stream.close(); img->create(); a->endWaitCursor(); } else { throw InvalidArgument("Loading failed!"); } return img; }
bool GNEDetectorE2::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return isValidDetectorID(value); case SUMO_ATTR_LANE: if (value.empty()) { return false; } else { return canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false); } case SUMO_ATTR_LANES: if (value.empty()) { return false; } else if (canParse<std::vector<GNELane*> >(myViewNet->getNet(), value, false)) { // check if lanes are consecutives return lanesConsecutives(parse<std::vector<GNELane*> >(myViewNet->getNet(), value)); } else { return false; } case SUMO_ATTR_POSITION: return canParse<double>(value); case SUMO_ATTR_ENDPOS: return canParse<double>(value); case SUMO_ATTR_FREQUENCY: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_LENGTH: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_NAME: return SUMOXMLDefinitions::isValidAttribute(value); case SUMO_ATTR_FILE: return SUMOXMLDefinitions::isValidFilename(value); case SUMO_ATTR_VTYPES: if (value.empty()) { return true; } else { return SUMOXMLDefinitions::isValidListOfTypeID(value); } case SUMO_ATTR_HALTING_TIME_THRESHOLD: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_HALTING_SPEED_THRESHOLD: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_JAM_DIST_THRESHOLD: return (canParse<double>(value) && (parse<double>(value) >= 0)); case SUMO_ATTR_FRIENDLY_POS: return canParse<bool>(value); case GNE_ATTR_BLOCK_MOVEMENT: return canParse<bool>(value); case GNE_ATTR_SELECTED: return canParse<bool>(value); case GNE_ATTR_GENERIC: return isGenericParametersValid(value); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void Dictionary::Add(const Dictionary& other) { for (auto& kv : *(other.m_dictionaryData)) { if (Contains(kv.first)) InvalidArgument("Dictionary::Add: This dictionary already contains an entry with key %S that is being attempted to add from the 'other' dictionary", kv.first.c_str()); (*this)[kv.first] = kv.second; } }
MSLane * NLDetectorBuilder::getLaneChecking(const std::string &id, const std::string &detid) throw(InvalidArgument) { // get and check the lane MSLane *clane = MSLane::dictionary(id); if (clane==0) { throw InvalidArgument("The lane with the id '" + id + "' is not known (while building detector '" + detid + "')."); } return clane; }
std::pair<SUMOReal, SUMOReal> GeomHelper::getNormal90D_CW(const Position& beg, const Position& end, SUMOReal length, SUMOReal wanted_offset) { if (beg == end) { throw InvalidArgument("same points at " + toString(beg)); } return std::pair<SUMOReal, SUMOReal> ((beg.y() - end.y()) * wanted_offset / length, (end.x() - beg.x()) * wanted_offset / length); }
void NLTriggerBuilder::buildBusStop(MSNet& net, const std::string& id, const std::vector<std::string>& lines, MSLane* lane, SUMOReal frompos, SUMOReal topos) { MSBusStop* stop = new MSBusStop(id, lines, *lane, frompos, topos); if (!net.addBusStop(stop)) { delete stop; throw InvalidArgument("Could not build bus stop '" + id + "'; probably declared twice."); } }
void NLDetectorBuilder::createEdgeLaneMeanData(const std::string& id, SUMOTime frequency, SUMOTime begin, SUMOTime end, const std::string& type, const bool useLanes, const bool withEmpty, const bool printDefaults, const bool withInternal, const bool trackVehicles, const double maxTravelTime, const double minSamples, const double haltSpeed, const std::string& vTypes, const std::string& device) { if (begin < 0) { throw InvalidArgument("Negative begin time for meandata dump '" + id + "'."); } if (end < 0) { end = SUMOTime_MAX; } if (end <= begin) { throw InvalidArgument("End before or at begin for meandata dump '" + id + "'."); } MSMeanData* det = 0; if (type == "" || type == "performance" || type == "traffic") { det = new MSMeanData_Net(id, begin, end, useLanes, withEmpty, printDefaults, withInternal, trackVehicles, maxTravelTime, minSamples, haltSpeed, vTypes); } else if (type == "emissions" || type == "hbefa") { if (type == "hbefa") { WRITE_WARNING("The netstate type 'hbefa' is deprecated. Please use the type 'emissions' instead."); } det = new MSMeanData_Emissions(id, begin, end, useLanes, withEmpty, printDefaults, withInternal, trackVehicles, maxTravelTime, minSamples, vTypes); } else if (type == "harmonoise") { det = new MSMeanData_Harmonoise(id, begin, end, useLanes, withEmpty, printDefaults, withInternal, trackVehicles, maxTravelTime, minSamples, vTypes); } else if (type == "amitran") { det = new MSMeanData_Amitran(id, begin, end, useLanes, withEmpty, printDefaults, withInternal, trackVehicles, maxTravelTime, minSamples, haltSpeed, vTypes); } else { throw InvalidArgument("Invalid type '" + type + "' for meandata dump '" + id + "'."); } if (det != 0) { if (frequency < 0) { frequency = end - begin; } MSNet::getInstance()->getDetectorControl().add(det, device, frequency, begin); } }
MSLane* NLDetectorBuilder::getLaneChecking(const std::string& laneID, SumoXMLTag type, const std::string& detid) { // get and check the lane MSLane* lane = MSLane::dictionary(laneID); if (lane == 0) { throw InvalidArgument("The lane with the id '" + laneID + "' is not known (while building " + toString(type) + " '" + detid + "')."); } return lane; }
bool Option_Float::set(const std::string &v) throw(InvalidArgument) { try { myValue = TplConvert<char>::_2SUMOReal(v.c_str()); return markSet(); } catch (...) { std::string s = "'" + v + "' is not a valid float (should be)."; throw InvalidArgument(s); } }
void NLEdgeControlBuilder::beginEdgeParsing( const std::string& id, const MSEdge::EdgeBasicFunction function, const std::string& streetName) { myActiveEdge = buildEdge(id, function, streetName); if (MSEdge::dictionary(id) != 0) { throw InvalidArgument("Another edge with the id '" + id + "' exists."); } myEdges.push_back(myActiveEdge); }
NDArrayView::NDArrayView(const NDShape& viewShape, const SparseIndexType* colStarts, const SparseIndexType* rowIndices, const ElementType* nonZeroValues, size_t numNonZeroValues, const DeviceDescriptor& device, bool readOnly/* = false*/) : NDArrayView(AsDataType<ElementType>(), device, StorageFormat::SparseCSC, viewShape, false, AllocateTensorView<ElementType>(viewShape, StorageFormat::SparseCSC, device)) { if ((colStarts == nullptr) || (rowIndices == nullptr) || (nonZeroValues == nullptr) || (numNonZeroValues == 0) || (numNonZeroValues > viewShape.TotalSize())) InvalidArgument("Invalid sparse CSC format initial data specified for NDArrayView construction"); auto sparseMatrix = GetWritableMatrix<ElementType>(1); sparseMatrix->SetMatrixFromCSCFormat(colStarts, rowIndices, nonZeroValues, numNonZeroValues, sparseMatrix->GetNumRows(), sparseMatrix->GetNumCols()); m_isReadOnly = readOnly; }
/*virtual*/ void ScatterPackedNode<ElemType>::ForwardPropNonLooping() /*override*/ { if (*Input(INDEXDATA)->GetMBLayout() != *Input(SOURCEDATA)->GetMBLayout()) InvalidArgument("%ls %ls operation requires the minibatch layout of index and source data to be the same.", NodeName().c_str(), OperationName().c_str()); Input(INDEXDATA)->MaskMissingValueColumnsTo(FrameRange(Input(INDEXDATA)->GetMBLayout()), -1); // indicates an invalid column to Gather/Scatter let& index = Input(INDEXDATA)->Value(); // column indices to copy from let& source = Input(SOURCEDATA)->Value(); // source data to copy auto& output = Value(); // output goes here output.DoScatterColumnsOf(/*beta=*/0, index, source, /*alpha=*/1); }
void InvertibleRSAFunction::Initialize(const Integer &n, const Integer &e, const Integer &d) { if (n.IsEven() || e.IsEven() | d.IsEven()) throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key"); m_n = n; m_e = e; m_d = d; Integer r = --(d*e); unsigned int s = 0; while (r.IsEven()) { r >>= 1; s++; } ModularArithmetic modn(n); for (Integer i = 2; ; ++i) { Integer a = modn.Exponentiate(i, r); if (a == 1) continue; Integer b; unsigned int j = 0; while (a != n-1) { b = modn.Square(a); if (b == 1) { m_p = GCD(a-1, n); m_q = n/m_p; m_dp = m_d % (m_p-1); m_dq = m_d % (m_q-1); m_u = m_q.InverseMod(m_p); return; } if (++j == s) throw InvalidArgument("InvertibleRSAFunction: input is not a valid RSA private key"); a = b; } } }
double Trainer::PreviousMinibatchEvaluationAverage() const { if (!m_evaluationFunction) InvalidArgument("Trainer::PreviousMinibatchEvaluationAverage: Cannot get evaluation criterion value when no evaluation function was specified during 'this' trainer's construction"); if (m_prevMinibatchNumSamples == 0) RuntimeError("There was no preceeding call to TrainMinibatch or the minibatch was empty."); return m_prevMinibatchAggregateEvalCriterionValue->AsScalar<double>() / m_prevMinibatchNumSamples; }
bool GNEPOI::isValid(SumoXMLAttr key, const std::string& value) { switch (key) { case SUMO_ATTR_ID: return SUMOXMLDefinitions::isValidNetID(value) && (myNet->retrievePOI(value, false) == nullptr); case SUMO_ATTR_COLOR: return canParse<RGBColor>(value); case SUMO_ATTR_LANE: return (myNet->retrieveLane(value, false) != nullptr); case SUMO_ATTR_POSITION: if (getLaneParents().size() > 0) { return canParse<double>(value); } else { return canParse<Position>(value); } case SUMO_ATTR_POSITION_LAT: return canParse<double>(value); case SUMO_ATTR_GEOPOSITION: { return canParse<Position>(value); } case SUMO_ATTR_GEO: return canParse<bool>(value); case SUMO_ATTR_TYPE: return true; case SUMO_ATTR_LAYER: if (value == "default") { return true; } else { return canParse<double>(value); } case SUMO_ATTR_IMGFILE: if (value == "") { return true; } else { // check that image can be loaded return GUITexturesHelper::getTextureID(value) != -1; } case SUMO_ATTR_RELATIVEPATH: return canParse<bool>(value); case SUMO_ATTR_WIDTH: return canParse<double>(value) && (parse<double>(value) >= 0); case SUMO_ATTR_HEIGHT: return canParse<double>(value) && (parse<double>(value) >= 0); case SUMO_ATTR_ANGLE: return canParse<double>(value); case GNE_ATTR_BLOCK_MOVEMENT: return canParse<bool>(value); case GNE_ATTR_SELECTED: return canParse<bool>(value); case GNE_ATTR_GENERIC: return isGenericParametersValid(value); default: throw InvalidArgument(getTagStr() + " doesn't have an attribute of type '" + toString(key) + "'"); } }
void NLDetectorBuilder::createEdgeLaneMeanData(const std::string &id, SUMOTime frequency, SUMOTime begin, SUMOTime end, const std::string &type, const bool useLanes, const bool withEmpty, const bool withInternal, const bool trackVehicles, const SUMOReal maxTravelTime, const SUMOReal minSamples, const SUMOReal haltSpeed, const std::string &vTypes, OutputDevice& device) throw(InvalidArgument) { if (begin < 0) { throw InvalidArgument("Negative begin time for meandata dump '" + id + "'."); } if (end < 0) { end = SUMOTime_MAX; } if (end <= begin) { throw InvalidArgument("End before or at begin for meandata dump '" + id + "'."); } std::set<std::string> vt; StringTokenizer st(vTypes); while (st.hasNext()) { vt.insert(st.next()); } MSMeanData *det = 0; if (type==""||type=="performance"||type=="traffic") { det = new MSMeanData_Net(id, begin, end, useLanes, withEmpty, trackVehicles, maxTravelTime, minSamples, haltSpeed, vt); } else if (type=="hbefa") { det = new MSMeanData_HBEFA(id, begin, end, useLanes, withEmpty, trackVehicles, maxTravelTime, minSamples, vt); } else if (type=="harmonoise") { det = new MSMeanData_Harmonoise(id, begin, end, useLanes, withEmpty, trackVehicles, maxTravelTime, minSamples, vt); } else { throw InvalidArgument("Invalid type '" + type + "' for meandata dump '" + id + "'."); } if (det!=0) { det->init(MSNet::getInstance()->getEdgeControl().getEdges(), withInternal); if (frequency < 0) { frequency = end - begin; } MSNet::getInstance()->getDetectorControl().addDetectorAndInterval(det, &device, frequency); } }
void NLEdgeControlBuilder::beginEdgeParsing(const std::string &id, MSEdge::EdgeBasicFunction function) throw(InvalidArgument) { myActiveEdge = buildEdge(id); if (!MSEdge::dictionary(id, myActiveEdge)) { throw InvalidArgument("Another edge with the id '" + id + "' exists."); } myEdges.push_back(myActiveEdge); m_pDepartLane = (MSLane*) 0; m_Function = function; }
StreamTransformationFilter::StreamTransformationFilter(StreamTransformation &c, BufferedTransformation *attachment, BlockPaddingScheme padding, bool allowAuthenticatedSymmetricCipher) : FilterWithBufferedInput(attachment) , m_cipher(c), m_padding(DEFAULT_PADDING), m_optimalBufferSize(0) { assert(c.MinLastBlockSize() == 0 || c.MinLastBlockSize() > c.MandatoryBlockSize()); if (!allowAuthenticatedSymmetricCipher && dynamic_cast<AuthenticatedSymmetricCipher *>(&c) != 0) throw InvalidArgument("StreamTransformationFilter: please use AuthenticatedEncryptionFilter and AuthenticatedDecryptionFilter for AuthenticatedSymmetricCipher"); IsolatedInitialize(MakeParameters(Name::BlockPaddingScheme(), padding)); }
void OptionsCont::addSynonyme(const std::string &name1, const std::string &name2) throw(InvalidArgument) { KnownContType::iterator i1 = myValues.find(name1); KnownContType::iterator i2 = myValues.find(name2); if (i1==myValues.end()&&i2==myValues.end()) { throw InvalidArgument("Neither the option '" + name1 + "' nor the option '" + name2 + "' is known yet"); } if (i1!=myValues.end()&&i2!=myValues.end()) { if ((*i1).second==(*i2).second) { return; } throw InvalidArgument("Both options '" + name1 + "' and '" + name2 + "' do exist and differ."); } if (i1==myValues.end()&&i2!=myValues.end()) { doRegister(name1, (*i2).second); } if (i1!=myValues.end()&&i2==myValues.end()) { doRegister(name2, (*i1).second); } }
void GNEHierarchicalElementChilds::addLaneChild(GNELane* lane) { // Check if lane is valid if (lane == nullptr) { throw InvalidArgument("Trying to add an empty lane child in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'"); } else { myLaneChilds.push_back(lane); // update connections geometry myChildConnections.update(); } }
const UniChar & UniChar::operator=(long long unsigned i) { if(!unicodePointValidity(i)) throw InvalidArgument("The value '%' is not a valid unicode point.", i); priv->val = i; priv->dirtyUtf8 = true; return *this; }
void GNEHierarchicalElementChilds::removeLaneChild(GNELane* lane) { // Check if lane is valid if (lane == nullptr) { throw InvalidArgument("Trying to remove an empty lane child in " + myAC->getTagStr() + " with ID='" + myAC->getID() + "'"); } else { myLaneChilds.erase(std::find(myLaneChilds.begin(), myLaneChilds.end(), lane)); // update connections geometry myChildConnections.update(); } }
boost::python::list NtTable::getColumn(int column) const { if (column < 0 || column >= nColumns) { throw InvalidArgument("Column index must be in range [0,%d].", nColumns-1); } std::string columnName = getColumnName(column); boost::python::list pyList; epics::pvData::PVStructurePtr pvStructurePtr2 = PyPvDataUtility::getStructureField(ValueFieldKey, pvStructurePtr); PyPvDataUtility::scalarArrayFieldToPyList(columnName, pvStructurePtr2, pyList); return pyList; }
void AuthenticatedSymmetricCipherBase::TruncatedFinal(byte *mac, size_t macSize) { if (m_totalHeaderLength > MaxHeaderLength()) throw InvalidArgument(AlgorithmName() + ": header length of " + IntToString(m_totalHeaderLength) + " exceeds the maximum of " + IntToString(MaxHeaderLength())); if (m_totalFooterLength > MaxFooterLength()) { if (MaxFooterLength() == 0) throw InvalidArgument(AlgorithmName() + ": additional authenticated data (AAD) cannot be input after data to be encrypted or decrypted"); else throw InvalidArgument(AlgorithmName() + ": footer length of " + IntToString(m_totalFooterLength) + " exceeds the maximum of " + IntToString(MaxFooterLength())); } switch (m_state) { case State_Start: case State_KeySet: throw BadState(AlgorithmName(), "TruncatedFinal", "setting key and IV"); case State_IVSet: AuthenticateLastHeaderBlock(); m_bufferedDataLength = 0; // fall through case State_AuthUntransformed: case State_AuthTransformed: AuthenticateLastConfidentialBlock(); m_bufferedDataLength = 0; // fall through case State_AuthFooter: AuthenticateLastFooterBlock(mac, macSize); m_bufferedDataLength = 0; break; default: CRYPTOPP_ASSERT(false); } m_state = State_KeySet; }
void GUITriggerBuilder::buildBusStop(MSNet& net, const std::string& id, const std::vector<std::string>& lines, MSLane* lane, SUMOReal frompos, SUMOReal topos) throw(InvalidArgument) { GUIBusStop* stop = new GUIBusStop(id, lines, *lane, frompos, topos); if (!net.addBusStop(stop)) { delete stop; throw InvalidArgument("Could not build bus stop '" + id + "'; probably declared twice."); } static_cast<GUINet&>(net).getVisualisationSpeedUp().addAdditionalGLObject(stop); }
return_value getReturnValue( const llvm::Type &type, const llvm::GenericValue &_value ) { switch ( type.getTypeID() ) { case llvm::Type::VoidTyID: return return_value(); case llvm::Type::IntegerTyID: case llvm::Type::FloatTyID: case llvm::Type::DoubleTyID: case llvm::Type::PointerTyID: default: throw InvalidArgument(); }; }
void OptionsCont::doRegister(const std::string &name, Option *v) throw(InvalidArgument) { assert(v!=0); ItemAddressContType::iterator i = find(myAddresses.begin(), myAddresses.end(), v); if (i==myAddresses.end()) { myAddresses.push_back(v); } if (myValues.find(name)!=myValues.end()) { throw InvalidArgument(name + " is an already used option name."); } myValues[name] = v; }
DecodingResult TF_DecryptorBase::Decrypt(RandomNumberGenerator &rng, const byte *ciphertext, size_t ciphertextLength, byte *plaintext, const NameValuePairs ¶meters) const { if (ciphertextLength != FixedCiphertextLength()) throw InvalidArgument(AlgorithmName() + ": ciphertext length of " + IntToString(ciphertextLength) + " doesn't match the required length of " + IntToString(FixedCiphertextLength()) + " for this key"); SecByteBlock paddedBlock(PaddedBlockByteLength()); Integer x = GetTrapdoorFunctionInterface().CalculateInverse(rng, Integer(ciphertext, ciphertextLength)); if (x.ByteCount() > paddedBlock.size()) x = Integer::Zero(); // don't return false here to prevent timing attack x.Encode(paddedBlock, paddedBlock.size()); return GetMessageEncodingInterface().Unpad(paddedBlock, PaddedBlockBitLength(), plaintext, parameters); }
void NLSucceedingLaneBuilder::closeSuccLane() throw(InvalidArgument) { MSLane *current = MSLane::dictionary(myCurrentLane); if (current==0) { throw InvalidArgument("Trying to close connections of an unknown lane ('" + myCurrentLane + "')."); } MSLinkCont *cont = new MSLinkCont(); cont->reserve(mySuccLanes->size()); copy(mySuccLanes->begin(), mySuccLanes->end(), back_inserter(*cont)); current->initialize(cont); mySuccLanes->clear(); }
lword FileStore::Skip(lword skipMax) { if (!m_stream) return 0; lword oldPos = m_stream->tellg(); std::istream::off_type offset; if (!SafeConvert(skipMax, offset)) throw InvalidArgument("FileStore: maximum seek offset exceeded"); m_stream->seekg(offset, std::ios::cur); return (lword)m_stream->tellg() - oldPos; }