IrcCommandInfo IrcCommandParserPrivate::parseSyntax(IrcCommand::Type type, const QString& syntax) { IrcCommandInfo cmd; QStringList tokens = syntax.split(QLatin1Char(' '), QString::SkipEmptyParts); if (!tokens.isEmpty()) { cmd.type = type; cmd.command = tokens.takeFirst().toUpper(); cmd.syntax = tokens.join(QLatin1String(" ")); cmd.max = tokens.count(); IrcParameterInfo param; for (int i = 0; i < tokens.count(); ++i) { const QString& token = tokens.at(i); param.optional = isOptional(token); param.channel = isChannel(token); param.current = isCurrent(token); param.multi = isMultiWord(token); if (!param.optional) ++cmd.min; if (param.optional && param.channel) ++cmd.min; const bool last = (i == tokens.count() - 1); if (last && param.multi) cmd.max = INT_MAX; cmd.params += param; } } return cmd; }
/** * @returns Empty string if empty value is valid, error message otherwise */ std::string MultipleFileProperty::isEmptyValueValid() const { if (isOptional()) { return ""; } else { return "No file specified."; } }
std::string QuestScale::toStringFile() const { std::stringstream ss; ss << path_ << " " << type_ << " " << low << " " << high << " " << text_ << isOptional(); return ss.str(); }
void QGpgMECryptoConfigEntry::setStringValueList( const QStringList& lst ) { mValue = lst; if ( lst.isEmpty() && !isOptional() ) mSet = false; else mSet = true; mDirty = true; }
void QGpgMECryptoConfigEntry::setURLValue( const KUrl& url ) { QString str = splitURL( mRealArgType, url ); if ( str.isEmpty() && !isOptional() ) mSet = false; else mSet = true; mValue = str; mDirty = true; }
// @mfunc Attempt to read the number of bytes given by <p bytes> // from the data stream into the buffer at address // <p buffer>. The actual number of bytes read is returned // in <p bytesRead>. // @parm The address of the buffer into which the bytes should be read. // @parm The number of bytes to read. // @parm The actual number of bytes that were read. // @this const void OMDataStreamProperty::read(OMByte* buffer, const OMUInt32 bytes, OMUInt32& bytesRead) const { TRACE("OMDataStreamProperty::read"); PRECONDITION("Optional property is present", IMPLIES(isOptional(), isPresent())); stream()->read(buffer, bytes, bytesRead); }
void QGpgMECryptoConfigEntry::setStringValue( const QString& str ) { mValue = stringToValue( str, false ); // When setting a string to empty (and there's no default), we need to act like resetToDefault // Otherwise we try e.g. "ocsp-responder:0:" and gpgconf answers: // "gpgconf: argument required for option ocsp-responder" if ( str.isEmpty() && !isOptional() ) mSet = false; else mSet = true; mDirty = true; }
void QGpgMECryptoConfigEntry::setUIntValueList( const QList<unsigned int>& lst ) { QList<QVariant> ret; for( QList<unsigned int>::const_iterator it = lst.constBegin(); it != lst.constEnd(); ++it ) { ret << QVariant( *it ); } if ( ret.isEmpty() && !isOptional() ) mSet = false; else mSet = true; mValue = ret; mDirty = true; }
void QGpgMECryptoConfigEntry::setURLValueList( const KUrl::List& urls ) { QStringList lst; for( KUrl::List::const_iterator it = urls.constBegin(); it != urls.constEnd(); ++it ) { lst << splitURL( mRealArgType, *it ); } mValue = lst; if ( lst.isEmpty() && !isOptional() ) mSet = false; else mSet = true; mDirty = true; }
void Argument1DString::writeData(QXmlStreamWriter &xmlWriter) { xmlWriter.writeStartElement("Argument1D"); { xmlWriter.writeAttribute("Id" , id()); xmlWriter.writeAttribute("Caption" , caption()); xmlWriter.writeAttribute("IsOptional" , isOptional() ? "True" : "False"); for(const QString& comment : comments()) { xmlWriter.writeComment(comment); } //write value definition; valueDefinitionInternal()->writeData(xmlWriter); xmlWriter.writeStartElement("Dimensions"); { xmlWriter.writeStartElement("Dimension"); { xmlWriter.writeAttribute("Id" , m_dimension->id()); xmlWriter.writeAttribute("Caption" , m_dimension->caption()); xmlWriter.writeAttribute("Length" , QString::number(length())); } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); xmlWriter.writeStartElement("Values"); { int ind[1] = {0}; int str[1] = {length()}; QString* values = new QString[length()]; getValues(ind,str,values); for(int i = 0 ; i < length() ; i++) { xmlWriter.writeStartElement("Value"); { xmlWriter.writeCharacters(values[i]); } xmlWriter.writeEndElement(); } delete[] values; } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); }
void ConsoleProgress::finishedDownloadHook(const string& uri, const string& result) { auto finishedDownloadRecordIt = this->getDownloadRecords().find(uri); size_t recordNumber = 0; if (finishedDownloadRecordIt != this->getDownloadRecords().end()) { recordNumber = finishedDownloadRecordIt->second.number; } else { warn2("internal error: console download progress: no existing download record for the uri '%s'", uri); } __impl->finishedDownload(uri, result, recordNumber, isOptional(uri)); }
/** * Set the loader option for use as a Child Algorithm. * @param loader :: Concrete loader * @param startProgress :: The start progress fraction * @param endProgress :: The end progress fraction * @param logging:: If true, enable logging */ void Load::setUpLoader(API::IAlgorithm_sptr &loader, const double startProgress, const double endProgress, const bool logging) const { // Set as a child so that we are in control of output storage loader->setChild(true); loader->setLogging(logging); // If output workspaces are nameless, give them a temporary name to satisfy // validator const std::vector<Property *> &props = loader->getProperties(); for (auto prop : props) { auto wsProp = dynamic_cast<IWorkspaceProperty *>(prop); if (wsProp && !wsProp->isOptional() && prop->direction() == Direction::Output) { if (prop->value().empty()) prop->setValue("LoadChildWorkspace"); } } if (startProgress >= 0. && endProgress > startProgress && endProgress <= 1.) { loader->addObserver(this->progressObserver()); setChildStartProgress(startProgress); setChildEndProgress(endProgress); } }
/** * Convert the given propValue into a comma and plus separated list of full *filenames, and pass to the parent's * setValue method to store as a vector of vector of strings. * * READ HEADER FILE DOCUMENTATION FOR A MORE DETAILED OVERVIEW. * * @param propValue :: A string of the allowed format, indicating the user's *choice of files. * @return A string indicating the outcome of the attempt to set the property. *An empty string indicates success. */ std::string MultipleFileProperty::setValue(const std::string &propValue) { // No empty value is allowed, unless optional. // This is yet aditional check that is beyond the underlying // MultiFileValidator, // so isOptional needs to be inspected here as well if (propValue.empty() && !isOptional()) return "No file(s) specified."; // If multiple file loading is disabled, then set value assuming it is a // single file. if (!m_multiFileLoadingEnabled) { g_log.debug( "MultiFile loading is not enabled, acting as standard FileProperty."); return setValueAsSingleFile(propValue); } try { // Else try and set the value, assuming it could be one or more files. return setValueAsMultipleFiles(propValue); } catch (const std::range_error &re) { // it was a valid multi file string but for too many files. return std::string(re.what()); } catch (const std::runtime_error &re) { g_log.debug( "MultiFile loading has failed. Trying as standard FileProperty."); const std::string error = setValueAsSingleFile(propValue); if (error.empty()) return ""; // If we failed return the error message from the multiple file load attempt // as the single file was a guess // and probably not what the user will expect to see return re.what(); } }
/*--------------------------------------------------------------*/ int NXVvalidateGroup(pNXVcontext self, hid_t groupID, xmlNodePtr groupNode) { hash_table namesSeen, baseNames; xmlNodePtr cur = NULL; xmlChar *name = NULL, *myClass = NULL; xmlChar *target = NULL; hid_t childID; char fName[256], childName[512], nxdlChildPath[512], childPath[512]; char mynxdlPath[512]; char *savedNXDLPath, *pPtr; SecondPassData spd; hsize_t idx = 0; /* manage nxdlPath, xmlGetNodePath does not work */ savedNXDLPath = self->nxdlPath; myClass = xmlGetProp(groupNode,(xmlChar *)"type"); if(self->nxdlPath == NULL) { snprintf(mynxdlPath,sizeof(mynxdlPath),"/%s", (char *) myClass); } else { snprintf(mynxdlPath,sizeof(mynxdlPath),"%s/%s", self->nxdlPath, (char *) myClass); } self->nxdlPath = mynxdlPath; /* tell what we are doing */ H5Iget_name(groupID,fName,sizeof(fName)); NXVsetLog(self,"sev","debug"); NXVsetLog(self,"message","Validating group"); NXVsetLog(self,"nxdlPath",self->nxdlPath); NXVsetLog(self,"dataPath",fName); NXVlog(self); validateGroupAttributes(self, groupID, groupNode); hash_construct_table(&namesSeen,100); /* first pass */ cur = groupNode->xmlChildrenNode; while(cur != NULL){ if(xmlStrcmp(cur->name,(xmlChar *) "group") == 0){ childID = findGroup(self, groupID, cur); if(childID >= 0){ H5Iget_name(childID, childName,sizeof(childName)); /* we have to get at the HDF5 name. There may be no name in the NXDL, but a suitable group has been found by NXclass. */ pPtr = strrchr(childName,'/'); if(pPtr != NULL){ hash_insert(pPtr+1,strdup(""),&namesSeen); } else { hash_insert(childName,strdup(""),&namesSeen); } NXVvalidateGroup(self,childID,cur); } else { name = xmlGetProp(cur,(xmlChar *)"type"); snprintf(nxdlChildPath,sizeof(nxdlChildPath),"%s/%s", self->nxdlPath, (char *)name); xmlFree(name); NXVsetLog(self,"dataPath",fName); NXVsetLog(self,"nxdlPath", nxdlChildPath); if(!isOptional(cur)){ NXVsetLog(self,"sev","error"); NXVsetLog(self,"message","Required group missing"); NXVlog(self); self->errCount++; } else { NXVsetLog(self,"sev","warnopt"); NXVsetLog(self,"message","Optional group missing"); NXVlog(self); } } } if(xmlStrcmp(cur->name,(xmlChar *) "field") == 0){ name = xmlGetProp(cur,(xmlChar *)"name"); if(H5LTfind_dataset(groupID,(char *)name) ) { childID = H5Dopen(groupID,(char *)name,H5P_DEFAULT); } else { childID = -1; } snprintf(childPath,sizeof(childPath),"%s/%s", fName,name); if(childID < 0){ NXVsetLog(self,"dataPath",childPath); snprintf(nxdlChildPath,sizeof(nxdlChildPath), "%s/%s", self->nxdlPath, name); NXVsetLog(self,"nxdlPath", nxdlChildPath); if(!isOptional(cur)){ NXVsetLog(self,"sev","error"); NXVsetLog(self,"message","Required field missing"); NXVlog(self); self->errCount++; } else { NXVsetLog(self,"sev","warnopt"); NXVsetLog(self,"message","Optional field missing"); NXVlog(self); } } else { if(xmlStrcmp(name,(xmlChar *)"depends_on") == 0){ /* This must b validated from the field level. As it might point to fields which are not in the application definition */ validateDependsOn(self,groupID,childID); } else { NXVvalidateField(self,childID, cur); } hash_insert((char *)name,strdup(""),&namesSeen); } xmlFree(name); } if(xmlStrcmp(cur->name,(xmlChar *) "link") == 0){ name = xmlGetProp(cur,(xmlChar *)"name"); target = xmlGetProp(cur,(xmlChar *)"target"); hash_insert((char *)name,strdup(""),&namesSeen); validateLink(self,groupID,name, target); xmlFree(name); xmlFree(target); } cur = cur->next; } /* Second pass: search the HDF5 group for additional stuff which have not checked yet. Most of the hard work is in the SecondPassIterator. */ hash_construct_table(&baseNames,100); NXVloadBaseClass(self,&baseNames,(char *)myClass); spd.baseNames = &baseNames; spd.namesSeen = &namesSeen; spd.self = self; NXVsetLog(self,"nxdlPath", mynxdlPath); H5Literate(groupID, H5_INDEX_NAME, H5_ITER_INC, &idx, SecondPassIterator, &spd); /* clean up */ hash_free_table(&namesSeen,free); hash_free_table(&baseNames,free); xmlFree(myClass); /* restore my paths... */ self->nxdlPath = savedNXDLPath; return 0; }
bool Argument1DString::writeToFile() const { if(currentArgumentIOType() == HydroCouple::File) { QFile file(m_inputFile.absoluteFilePath()); if(file.open(QIODevice::WriteOnly)) { QXmlStreamWriter xmlWriter(&file); xmlWriter.setAutoFormatting(true); xmlWriter.writeStartElement("Argument1D"); { xmlWriter.writeAttribute("Id" , id()); xmlWriter.writeAttribute("Caption" , caption()); xmlWriter.writeAttribute("IsOptional" , isOptional() ? "True" : "False"); for(const QString& comment : comments()) { xmlWriter.writeComment(comment); } //write value definition; valueDefinitionInternal()->writeData(xmlWriter); xmlWriter.writeStartElement("Dimensions"); { xmlWriter.writeStartElement("Dimension"); { xmlWriter.writeAttribute("Id" , m_dimension->id()); xmlWriter.writeAttribute("Caption" , m_dimension->caption()); xmlWriter.writeAttribute("Length" , QString::number(length())); } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); xmlWriter.writeStartElement("Values"); { int ind[1] = {0}; int str[1] = {length()}; QString *values = new QString[length()]; getValues(ind,str,values); for(int i = 0 ; i < length() ; i++) { xmlWriter.writeStartElement("Value"); { xmlWriter.writeCharacters(values[i]); } xmlWriter.writeEndElement(); } delete[] values; } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); file.close(); return false; } } return false; }
QString Argument1DDouble::toString() const { if(currentArgumentIOType() == HydroCouple::File) { return QFileInfo(modelComponent()->componentInfo()->libraryFilePath()).absoluteDir().relativeFilePath(m_inputFile.absoluteFilePath()); } else { QString data; QXmlStreamWriter xmlWriter(&data); xmlWriter.setAutoFormatting(true); xmlWriter.writeStartDocument(); { xmlWriter.writeStartElement("Argument1D"); { xmlWriter.writeAttribute("Id" , id()); xmlWriter.writeAttribute("Caption" , caption()); xmlWriter.writeAttribute("IsOptional" , isOptional() ? "True" : "False"); for(const QString& comment : comments()) { xmlWriter.writeComment(comment); } //write value definition; valueDefinitionInternal()->writeData(xmlWriter); xmlWriter.writeStartElement("Dimensions"); { xmlWriter.writeStartElement("Dimension"); { xmlWriter.writeAttribute("Id" , m_dimension->id()); xmlWriter.writeAttribute("Caption" , m_dimension->caption()); xmlWriter.writeAttribute("Length" , QString::number(length())); } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); xmlWriter.writeStartElement("Values"); { int ind[1] = {0}; int str[1] = {length()}; double values[length()]; getValues(ind,str,values); for(int i = 0 ; i < length() ; i++) { xmlWriter.writeStartElement("Value"); { xmlWriter.writeCharacters(QString::number(values[i])); } xmlWriter.writeEndElement(); } } xmlWriter.writeEndElement(); } xmlWriter.writeEndElement(); } xmlWriter.writeEndDocument(); return data; } }
// @mfunc Attempt to read the number of elements given by // <p elementCount> and described by <p elementType> and // <p externalElementSize> from the data stream into the buffer // at address <p elements>. The actual number of elements read // is returned in <p elementsRead>. // @parm The element type // @parm The external element size // @parm The address of the buffer into which the elements should be read. // @parm The number of elements to read. // @parm The actual number of elements that were read. // @this const void OMDataStreamProperty::readTypedElements(const OMType* elementType, OMUInt32 externalElementSize, OMByte* elements, OMUInt32 elementCount, OMUInt32& elementsRead) const { TRACE("OMDataStreamProperty::readTypedElements"); PRECONDITION("Optional property is present", IMPLIES(isOptional(), isPresent())); PRECONDITION("Valid element type", elementType != 0); PRECONDITION("Valid element size", externalElementSize!= 0); PRECONDITION("Valid buffer", elements != 0); PRECONDITION("Valid element count", elementCount > 0); PRECONDITION("Stream byte order is known", hasByteOrder()); OMUInt64 currentPosition = position(); OMUInt64 streamSize = size(); OMUInt32 readCount = 0; if (currentPosition < streamSize) { OMUInt64 remaining = (streamSize - currentPosition) / externalElementSize; if (remaining < elementCount) { readCount = static_cast<OMUInt32>(remaining); } else { readCount = elementCount; } } if (readCount > 0) { bool reorder = false; if (byteOrder() != hostByteOrder()) { reorder = true; } // Allocate buffer for one element OMByte* buffer = new OMByte[externalElementSize]; for (OMUInt32 i = 0; i < readCount; i++) { // Read an element of the property value OMUInt32 actualByteCount; read(buffer, externalElementSize, actualByteCount); ASSERT("All bytes read", actualByteCount == externalElementSize); // Reorder an element of the property value if (reorder) { elementType->reorder(buffer, externalElementSize); } // Internalize an element of the property value OMUInt32 requiredBytesSize = elementType->internalSize( buffer, externalElementSize); elementType->internalize(buffer, externalElementSize, &elements[i * requiredBytesSize], requiredBytesSize, hostByteOrder()); } delete [] buffer; } elementsRead = readCount; }
bool AbstractInputSlot::isUsable() const { return isOptional() || isConnected(); }