Make itervar-values contained in sca- and vec-files available to R

R-package/R/loadDataset.R

@@ -50,7 +50,8 @@ loadDataset <- function(files, ...) {
       fields = as.data.frame(dataset$fields),
       bins = as.data.frame(dataset$bins),
       params = as.data.frame(dataset$params),
-      attrs = as.data.frame(dataset$attrs)
+      attrs = as.data.frame(dataset$attrs),
+      itervars = as.data.frame(dataset$itervars)
     ),
     class='omnetpp_dataset'
   )

R-package/src/loadDataset.cc

@@ -195,7 +195,7 @@ static IDList filterIDListByType(const IDList &idlist, int type, const ResultFil
     return result;
 }
 
-static const char* datasetColumnNames[] = {"runattrs", "fileruns", "scalars", "vectors", "statistics", "fields", "bins", "params", "attrs"};
+static const char* datasetColumnNames[] = {"runattrs", "fileruns", "scalars", "vectors", "statistics", "fields", "bins", "params", "attrs", "itervars"};
 static const int datasetColumnsLength = sizeof(datasetColumnNames) / sizeof(const char*);
 
 const char* runColumnNames[] = {"runid", "attrname", "attrvalue"};
@@ -234,12 +234,16 @@ const char* attributeColumnNames[] = {"attrtype", "resultkey", "attrname", "attr
 const SEXPTYPE attributeColumnTypes[] = {STRSXP, INTSXP, STRSXP, STRSXP};
 const int attributeColumnsLength = sizeof(attributeColumnNames) / sizeof(const char*);
 
+const char* itervarsColumnNames[] = {"runid", "varname", "varvalue"};
+const SEXPTYPE itervarsColumnTypes[] = {STRSXP, STRSXP, STRSXP};
+const int itervarsColumnsLength = sizeof(itervarsColumnNames) / sizeof(const char*);
+
 SEXP exportDataset(ResultFileManager &manager, const IDList &idlist)
 {
-    int paramsCount = 0, attrCount = 0, runAttrCount = 0;
+    int paramsCount = 0, attrCount = 0, runAttrCount = 0, itervarCount = 0;
 
     SEXP dataset;
-    PROTECT(dataset = NEW_LIST(9));
+    PROTECT(dataset = NEW_LIST(datasetColumnsLength));
     setNames(dataset, datasetColumnNames, datasetColumnsLength);
 
     // runattrs
@@ -250,6 +254,7 @@ SEXP exportDataset(ResultFileManager &manager, const IDList &idlist)
         Run *runPtr = runList->at(i);
         paramsCount += runPtr->moduleParams.size();
         runAttrCount += runPtr->attributes.size();
+        itervarCount += runPtr->itervars.size();
     }
     SEXP runattrs = createDataFrame(runColumnNames, runColumnTypes, runColumnsLength, runAttrCount);
     SEXP runid=VECTOR_ELT(runattrs,0), name=VECTOR_ELT(runattrs,1), value=VECTOR_ELT(runattrs,2);
@@ -447,6 +452,29 @@ SEXP exportDataset(ResultFileManager &manager, const IDList &idlist)
     addResultItemAttributes(attrs, index, "vector", vectorIDs, vectorKeyStart, manager);
     addResultItemAttributes(attrs, index, "statistic", statisticIDs, statisticKeyStart, manager);
 
+    SEXP itervars = createDataFrame(itervarsColumnNames, itervarsColumnTypes, itervarsColumnsLength, itervarCount);
+    SET_ELEMENT(dataset, 9, itervars);
+    UNPROTECT(1);
+    runid = VECTOR_ELT(itervars, 0);
+    name = VECTOR_ELT(itervars, 1);
+    value = VECTOR_ELT(itervars, 2);
+    index = 0;
+    for (int i = 0; i < runCount; i++) {
+
+       Run* run = runList->at(i);
+       SEXP runidSexp = mkChar(run->runName.c_str());
+       for (StringMap::const_iterator it=run->itervars.begin(); it != run->itervars.end(); ++it)
+       {
+           const char *nameStr = it->first.c_str();
+           const char *valueStr = it->second.c_str();
+           SET_STRING_ELT(runid, index, runidSexp);
+           SET_STRING_ELT(name, index, mkChar(nameStr));
+           SET_STRING_ELT(value, index, mkChar(valueStr));
+           index++;
+       }
+
+    }
+
     UNPROTECT(1); // dataset
 
     delete runList;

R-package/src/scave/dataflownetworkbuilder.cc

@@ -341,7 +341,7 @@ DataflowManager* PNetwork::createDataflowNetwork()
 
 DataflowNetworkBuilder::~DataflowNetworkBuilder()
 {
-    // TODO
+  delete dataflowManagerPtr;
 }
 
 void DataflowNetworkBuilder::build(const IDList &input, const ProcessingOperationList &operations)

R-package/src/scave/indexedvectorfilereader.cc

@@ -90,8 +90,6 @@ void IndexedVectorFileReaderNode::readIndexFile()
 
     if (!IndexFile::isVectorFile(fn))
         throw opp_runtime_error("indexed vector file reader: not a vector file, file %s", fn);
-    if (!IndexFile::isIndexFileUpToDate(fn))
-        throw opp_runtime_error("indexed vector file reader: index file is not up to date, file %s", fn);
 
     string indexFileName = IndexFile::getIndexFileName(fn);
     IndexFileReader reader(indexFileName.c_str());

R-package/src/scave/indexfile.cc

@@ -423,6 +423,9 @@ void IndexFileReader::parseLine(char **tokens, int numTokens, VectorFileIndex *i
         CHECK(parseInt(tokens[1], version), "version is not a number", lineNum);
         CHECK(version <= 2, "expects version 2 or lower", lineNum);
     }
+    else if (tokens[0][0] == 'i' && strcmp(tokens[0], "itervar") == 0) {
+        return;
+    }
     else if (index->run.parseLine(tokens, numTokens, filename.c_str(), lineNum))
     {
         return;

R-package/src/scave/resultfilemanager.cc

@@ -1082,6 +1082,19 @@ void ResultFileManager::processLine(char **vec, int numTokens, sParseContext &ct
         HistogramResult &histogram = ctx.fileRef->histogramResults.back();
         histogram.addBin(lower_bound, value);
     }
+    else if (vec[0][0]=='i' && !strcmp(vec[0],"itervar")) {
+
+        CHECK(numTokens>=3, "invalid result file: 'itervar <name> <value>' expected");
+
+        std::string varName = vec[1];
+        std::string varValue = vec[2];
+
+        StringMap &itervars = ctx.fileRunRef->runRef->itervars;
+        StringMap::iterator oldRef = itervars.find(varName);
+        CHECK(oldRef == itervars.end() || oldRef->second == varValue,
+           "Value of iteration variable conflicts with previously loaded value");
+        itervars[varName] = varValue;
+    }
     else if (vec[0][0]=='a' && !strcmp(vec[0],"attr"))
     {
         CHECK(numTokens>=3, "invalid result file: 'attr <name> <value>' expected");

R-package/src/scave/resultfilemanager.h

@@ -208,6 +208,9 @@ struct SCAVE_API Run
     StringMap attributes;
     int runNumber; // this is stored separately as well, for convenience
 
+    // iteration variables, denotes by "itervar"
+    StringMap itervars;
+
     // module parameters: maps wildcard pattern to value
     StringMap moduleParams;
 
@@ -217,6 +220,12 @@ struct SCAVE_API Run
         StringMap::const_iterator it = attributes.find(attrName);
         return it==attributes.end() ? NULL : it->second.c_str();
     }
+
+    const char *getIterationVariable(const char *varName) const {
+        StringMap::const_iterator it = itervars.find(varName);
+        return it==itervars.end() ? NULL : it->second.c_str();
+    }
+
     const char *getModuleParam(const char *paramName) const {
         StringMap::const_iterator it = moduleParams.find(paramName);
         return it==moduleParams.end() ? NULL : it->second.c_str();