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