deleted file mode 100644

@@ -1,61 +0,0 @@

-//

-// Based on code sent by Kevin Ushey

-// to Rcpp-devel on Tue, 8 Jul 2014

-//

-

-#ifndef LIST_BUILDER_H

-#define LIST_BUILDER_H

-

-#include <Rcpp.h>

-using namespace Rcpp;

-

-class ListBuilder

-{

-

-public:

-

-    ListBuilder() {};

-    ~ListBuilder() {};

-

-    inline ListBuilder& add(std::string name, SEXP x)

-    {

-        names.push_back(name);

-        elements.push_back(x);

-        return *this;

-    }

-

-    inline List get() const

-    {

-        return static_cast<List>(*this);

-    }

-

-    inline operator List() const

-    {

-        List result(elements.size());

-        for (size_t i = 0; i < elements.size(); ++i)

-        {

-            result[i] = elements[i];

-        }

-        result.attr("names") = wrap(names);

-        return result;

-    }

-

-    inline operator DataFrame() const

-    {

-        List result = static_cast<List>(*this);

-        result.attr("class") = "data.frame";

-        result.attr("row.names") = IntegerVector::create(NA_INTEGER, XLENGTH(elements[0]));

-        return result;

-    }

-

-private:

-

-    std::vector<std::string> names;

-    std::vector<SEXP> elements;

-

-    ListBuilder(ListBuilder const&) {};

-

-};

-

-

-#endif

@@ -1,5 +1,4 @@

 #include "RcppIdent.h"

-#include "ListBuilder.h"

 RcppIdent::RcppIdent()

 {

@@ -184,7 +183,6 @@ Rcpp::DataFrame RcppIdent::getPsmInfo(  )

 Rcpp::DataFrame RcppIdent::getModInfo(  )

 {

-    ListBuilder res;

     vector<SpectrumIdentificationResultPtr> spectrumIdResult = mzid->analysisCollection.spectrumIdentification[0]->spectrumIdentificationListPtr->spectrumIdentificationResult;

     vector<string> spectrumID;

@@ -303,50 +301,72 @@ Rcpp::DataFrame RcppIdent::getScore(  )

             }

         }

-        ListBuilder res;

-        res.add("spectrumID", Rcpp::wrap(spectrumID));

+        Rcpp::List res(score.size() + 1);

+        

+        names.insert(names.begin(), "spectrumID");

+        

+        res[0] = Rcpp::wrap(spectrumID);

+        

         for(size_t i = 0; i < score.size(); i++)

         {

-            res.add(underscore(names[i]), Rcpp::wrap(score[i]));

+			res[i + 1] = Rcpp::wrap(score[i]);

         }

+        

+        res.attr("names") = names;

+        Rcpp::DataFrame out(res);

-        return res;

+        return out;

     }

-

-

 }

 Rcpp::List RcppIdent::getPara(  )

 {

-    ListBuilder para;

-    vector<SpectrumIdentificationProtocolPtr> sip = mzid->analysisProtocolCollection.spectrumIdentificationProtocol;

-    para.add("searchType", Rcpp::wrap(underscore(cvTermInfo(sip[0]->searchType.cvid).name)));

+    std::vector<SpectrumIdentificationProtocolPtr> sip = mzid->analysisProtocolCollection.spectrumIdentificationProtocol;

+	std::vector<std::string> names, values;

+	names.push_back("searchType");

+	values.push_back(underscore(cvTermInfo(sip[0]->searchType.cvid).name));

+	

     for(int i = 0 ; i < sip[0]->additionalSearchParams.cvParams.size(); i++)

     {

-        para.add(underscore(cvTermInfo(sip[0]->additionalSearchParams.cvParams[i].cvid).name), Rcpp::wrap((bool) 1));

-    }

+		names.push_back(underscore(cvTermInfo(sip[0]->additionalSearchParams.cvParams[i].cvid).name));

+		values.push_back("true");

+	}

     for(int i = 0; i < sip[0]->additionalSearchParams.userParams.size(); i++)

     {

+		names.push_back(underscore(sip[0]->additionalSearchParams.userParams[i].name));

         if(sip[0]->additionalSearchParams.userParams[i].value.empty())

         {

-            para.add(underscore(sip[0]->additionalSearchParams.userParams[i].name), Rcpp::wrap((bool) 1));

-        }

-        else if(isNumber(sip[0]->additionalSearchParams.userParams[i].value))

-        {

-            para.add(underscore(sip[0]->additionalSearchParams.userParams[i].name), Rcpp::wrap(lexical_cast<double>(sip[0]->additionalSearchParams.userParams[i].value)));

+			values.push_back("true");

         }

-        else if(isBool(sip[0]->additionalSearchParams.userParams[i].value))

+        else

         {

-            para.add(underscore(sip[0]->additionalSearchParams.userParams[i].name), Rcpp::wrap(toBool(sip[0]->additionalSearchParams.userParams[i].value)));

+			values.push_back(sip[0]->additionalSearchParams.userParams[i].value);

         }

-        else

-            para.add(underscore(sip[0]->additionalSearchParams.userParams[i].name), Rcpp::wrap(sip[0]->additionalSearchParams.userParams[i].value));

     }

-

-    return para;

+    

+    Rcpp::List res(names.size());

+    

+    for (size_t i = 0; i < names.size(); i++)

+    {

+		if (isNumber(values[i]))

+		{

+			res[i] = Rcpp::wrap(lexical_cast<double>(values[i]));

+		}

+		else if (isBool(values[i]))

+		{

+			res[i] = Rcpp::wrap(toBool(values[i]));

+		}

+		else

+		{

+			res[i] = Rcpp::wrap(values[i]);

+		}

+	}

+    

+    res.attr("names") = names;

+    return res;

 }

 Rcpp::DataFrame RcppIdent::getDB(  )

@@ -1,7 +1,5 @@

 #include "RcppPwiz.h"

-#include "ListBuilder.h"

-

 RcppPwiz::RcppPwiz()

 {

     msd = NULL;

@@ -140,30 +138,54 @@ Rcpp::List RcppPwiz::getScanHeaderInfo ( int whichScan  )

         ScanHeaderStruct header;

         adapter->getScanHeader(whichScan - 1, header);

-        ListBuilder res;

-

-        res.add("seqNum",				Rcpp::wrap(header.seqNum));

-        res.add("acquisitionNum",		Rcpp::wrap(header.acquisitionNum));

-        res.add("msLevel",				Rcpp::wrap(header.msLevel));

-        res.add("polarity",				Rcpp::wrap(header.polarity));

-        res.add("peaksCount",			Rcpp::wrap(header.peaksCount));

-        res.add("totIonCurrent",		Rcpp::wrap(header.totIonCurrent));

-        res.add("retentionTime",		Rcpp::wrap(header.retentionTime));

-        res.add("basePeakMZ",			Rcpp::wrap(header.basePeakMZ));

-        res.add("basePeakIntensity",	Rcpp::wrap(header.basePeakIntensity));

-        res.add("collisionEnergy",		Rcpp::wrap(header.collisionEnergy));

-        res.add("ionisationEnergy",		Rcpp::wrap(header.ionisationEnergy));

-        res.add("lowMZ",				Rcpp::wrap(header.lowMZ));

-        res.add("highMZ",				Rcpp::wrap(header.highMZ));

-        res.add("precursorScanNum",		Rcpp::wrap(header.precursorScanNum));

-        res.add("precursorMZ",			Rcpp::wrap(header.precursorMZ));

-        res.add("precursorCharge",		Rcpp::wrap(header.precursorCharge));

-        res.add("precursorIntensity",	Rcpp::wrap(header.precursorIntensity));

-        res.add("mergedScan",			Rcpp::wrap(header.mergedScan));

-        res.add("mergedResultScanNum",	Rcpp::wrap(header.mergedResultScanNum));

-        res.add("mergedResultStartScanNum",	Rcpp::wrap(header.mergedResultStartScanNum));

-        res.add("mergedResultEndScanNum",	Rcpp::wrap(header.mergedResultEndScanNum));

-

+        Rcpp::List res(21);

+        std::vector<std::string> names;

+        int i = 0;

+

+        names.push_back("seqNum");

+        res[i++] = Rcpp::wrap(header.seqNum);

+        names.push_back("acquisitionNum");

+        res[i++] = Rcpp::wrap(header.acquisitionNum);

+        names.push_back("msLevel");

+        res[i++] = Rcpp::wrap(header.msLevel);

+        names.push_back("polarity");

+        res[i++] = Rcpp::wrap(header.polarity);

+        names.push_back("peaksCount");

+        res[i++] = Rcpp::wrap(header.peaksCount);

+        names.push_back("totIonCurrent");

+        res[i++] = Rcpp::wrap(header.totIonCurrent);

+        names.push_back("retentionTime");

+        res[i++] = Rcpp::wrap(header.retentionTime);

+        names.push_back("basePeakMZ");

+        res[i++] = Rcpp::wrap(header.basePeakMZ);

+        names.push_back("basePeakIntensity");

+        res[i++] = Rcpp::wrap(header.basePeakIntensity);

+        names.push_back("collisionEnergy");

+        res[i++] = Rcpp::wrap(header.collisionEnergy);

+        names.push_back("ionisationEnergy");

+        res[i++] = Rcpp::wrap(header.ionisationEnergy);

+        names.push_back("lowMZ");

+        res[i++] = Rcpp::wrap(header.lowMZ);

+        names.push_back("highMZ");

+        res[i++] = Rcpp::wrap(header.highMZ);

+        names.push_back("precursorScanNum");

+        res[i++] = Rcpp::wrap(header.precursorScanNum);

+        names.push_back("precursorMZ");

+        res[i++] = Rcpp::wrap(header.precursorMZ);

+        names.push_back("precursorCharge");

+        res[i++] = Rcpp::wrap(header.precursorCharge);

+        names.push_back("precursorIntensity");

+        res[i++] = Rcpp::wrap(header.precursorIntensity);

+        names.push_back("mergedScan");

+        res[i++] = Rcpp::wrap(header.mergedScan);

+        names.push_back("mergedResultScanNum");

+        res[i++] = Rcpp::wrap(header.mergedResultScanNum);

+        names.push_back("mergedResultStartScanNum");

+        res[i++] = Rcpp::wrap(header.mergedResultStartScanNum);

+        names.push_back("mergedResultEndScanNum");

+        res[i++] = Rcpp::wrap(header.mergedResultEndScanNum);

+

+        res.attr("names") = names;

         return res;

     }

     else

@@ -237,30 +259,55 @@ Rcpp::DataFrame RcppPwiz::getAllScanHeaderInfo ( )

                 mergedResultEndScanNum[whichScan-1] = scanHeader.mergedResultEndScanNum;

             }

-            ListBuilder header;

-            header.add("seqNum", seqNum);

-            header.add("acquisitionNum",	acquisitionNum);

-            header.add("msLevel",           msLevel);

-            header.add("polarity",          polarity);

-            header.add("peaksCount",        peaksCount);

-            header.add("totIonCurrent",     totIonCurrent);

-            header.add("retentionTime",     retentionTime);

-            header.add("basePeakMZ",        basePeakMZ);

-            header.add("basePeakIntensity", basePeakIntensity);

-            header.add("collisionEnergy",   collisionEnergy);

-            header.add("ionisationEnergy",  ionisationEnergy);

-            header.add("lowMZ",             lowMZ);

-            header.add("highMZ",            highMZ);

-            header.add("precursorScanNum",  precursorScanNum);

-            header.add("precursorMZ",       precursorMZ);

-            header.add("precursorCharge",   precursorCharge);

-            header.add("precursorIntensity",precursorIntensity);

-            header.add("mergedScan",        mergedScan);

-            header.add("mergedResultScanNum",      mergedResultScanNum);

-            header.add("mergedResultStartScanNum", mergedResultStartScanNum);

-            header.add("mergedResultEndScanNum",   mergedResultEndScanNum);

-

-            allScanHeaderInfo = header.get();

+            Rcpp::List header(21);

+            std::vector<std::string> names;

+            int i = 0;

+            names.push_back("seqNum");

+            header[i++] = Rcpp::wrap(seqNum);

+            names.push_back("acquisitionNum");

+            header[i++] = Rcpp::wrap(acquisitionNum);

+            names.push_back("msLevel");

+            header[i++] = Rcpp::wrap(msLevel);

+            names.push_back("polarity");

+            header[i++] = Rcpp::wrap(polarity);

+            names.push_back("peaksCount");

+            header[i++] = Rcpp::wrap(peaksCount);

+            names.push_back("totIonCurrent");

+            header[i++] = Rcpp::wrap(totIonCurrent);

+            names.push_back("retentionTime");

+            header[i++] = Rcpp::wrap(retentionTime);

+            names.push_back("basePeakMZ");

+            header[i++] = Rcpp::wrap(basePeakMZ);

+            names.push_back("basePeakIntensity");

+            header[i++] = Rcpp::wrap(basePeakIntensity);

+            names.push_back("collisionEnergy");

+            header[i++] = Rcpp::wrap(collisionEnergy);

+            names.push_back("ionisationEnergy");

+            header[i++] = Rcpp::wrap(ionisationEnergy);

+            names.push_back("lowMZ");

+            header[i++] = Rcpp::wrap(lowMZ);

+            names.push_back("highMZ");

+            header[i++] = Rcpp::wrap(highMZ);

+            names.push_back("precursorScanNum");

+            header[i++] = Rcpp::wrap(precursorScanNum);

+            names.push_back("precursorMZ");

+            header[i++] = Rcpp::wrap(precursorMZ);

+            names.push_back("precursorCharge");

+            header[i++] = Rcpp::wrap(precursorCharge);

+            names.push_back("precursorIntensity");

+            header[i++] = Rcpp::wrap(precursorIntensity);

+            names.push_back("mergedScan");

+            header[i++] = Rcpp::wrap(mergedScan);

+            names.push_back("mergedResultScanNum");

+            header[i++] = Rcpp::wrap(mergedResultScanNum);

+            names.push_back("mergedResultStartScanNum");

+            header[i++] = Rcpp::wrap(mergedResultStartScanNum);

+            names.push_back("mergedResultEndScanNum");

+            header[i++] = Rcpp::wrap(mergedResultEndScanNum);

+

+			header.attr("names") = names;

+

+            allScanHeaderInfo = header;

             isInCacheAllScanHeaderInfo = TRUE;

         }

         return(allScanHeaderInfo);

@@ -1,8 +1,5 @@

 #include "RcppRamp.h"

-#include "ListBuilder.h"

-

-

 RcppRamp::RcppRamp()

 {

     ramp = NULL;

@@ -150,37 +147,54 @@ Rcpp::List RcppRamp::getScanHeaderInfo ( int whichScan  )

         ScanHeaderStruct data = info->m_data;

         delete info;

-        //    Rcpp::List header = Rcpp::List::create();

-        ListBuilder header;

+        std::vector<std::string> names;

+        Rcpp::List header(21);

+        int i = 0;

-        header.add("seqNum",  Rcpp::wrap(data.seqNum));

-        header.add("acquisitionNum", Rcpp::wrap(data.acquisitionNum));

-        header.add("msLevel",       Rcpp::wrap(data.msLevel));

-        header.add("polarity",       Rcpp::wrap(data.polarity));

-        header.add("peaksCount",       Rcpp::wrap(data.peaksCount));

-        header.add("totIonCurrent",       Rcpp::wrap(data.totIonCurrent));

-        header.add("retentionTime",       Rcpp::wrap(data.retentionTime));

-        header.add("basePeakMZ",       Rcpp::wrap(data.basePeakMZ));

-        header.add("basePeakIntensity",       Rcpp::wrap(data.basePeakIntensity));

-        header.add("collisionEnergy",       Rcpp::wrap(data.collisionEnergy));

-        header.add("ionisationEnergy",       Rcpp::wrap(data.ionisationEnergy));

-        header.add("lowMZ",       Rcpp::wrap(data.lowMZ));

-        header.add("highMZ",       Rcpp::wrap(data.highMZ));

-        header.add("precursorScanNum",       Rcpp::wrap(data.precursorScanNum));

-        header.add("precursorMZ",       Rcpp::wrap(data.precursorMZ));

-        header.add("precursorCharge",       Rcpp::wrap(data.precursorCharge));

-        header.add("precursorIntensity",       Rcpp::wrap(data.precursorIntensity));

-        //  header.add("scanType",       Rcpp::wrap(data.scanType));

-        //  header.add("activationMethod",       Rcpp::wrap(data.activationMethod));

-        //  header.add("possibleCharges",       Rcpp::wrap(data.possibleCharges));

-        // header.add("numPossibleCharges",       Rcpp::wrap(data.numPossibleCharges));

-        //  header.add("possibleChargesArray",       Rcpp::wrap(data.possibleChargesArray));

-        header.add("mergedScan",       Rcpp::wrap(data.mergedScan));

-        header.add("mergedResultScanNum",       Rcpp::wrap(data.mergedResultScanNum));

-        header.add("mergedResultStartScanNum",       Rcpp::wrap(data.mergedResultStartScanNum));

-        header.add("mergedResultEndScanNum",       Rcpp::wrap(data.mergedResultEndScanNum));

-        //			     header.add("filePosition",       data.filePosition

+        names.push_back("seqNum");

+        header[i++] = Rcpp::wrap(data.seqNum);

+        names.push_back("acquisitionNum");

+        header[i++] = Rcpp::wrap(data.acquisitionNum);

+        names.push_back("msLevel");

+        header[i++] = Rcpp::wrap(data.msLevel);

+        names.push_back("polarity");

+        header[i++] = Rcpp::wrap(data.polarity);

+        names.push_back("peaksCount");

+        header[i++] = Rcpp::wrap(data.peaksCount);

+        names.push_back("totIonCurrent");

+        header[i++] = Rcpp::wrap(data.totIonCurrent);

+        names.push_back("retentionTime");

+        header[i++] = Rcpp::wrap(data.retentionTime);

+        names.push_back("basePeakMZ");

+        header[i++] = Rcpp::wrap(data.basePeakMZ);

+        names.push_back("basePeakIntensity");

+        header[i++] = Rcpp::wrap(data.basePeakIntensity);

+        names.push_back("collisionEnergy");

+        header[i++] = Rcpp::wrap(data.collisionEnergy);

+        names.push_back("ionisationEnergy");

+        header[i++] = Rcpp::wrap(data.ionisationEnergy);

+        names.push_back("lowMZ");

+        header[i++] = Rcpp::wrap(data.lowMZ);

+        names.push_back("highMZ");

+        header[i++] = Rcpp::wrap(data.highMZ);

+        names.push_back("precursorScanNum");

+        header[i++] = Rcpp::wrap(data.precursorScanNum);

+        names.push_back("precursorMZ");

+        header[i++] = Rcpp::wrap(data.precursorMZ);

+        names.push_back("precursorCharge");

+        header[i++] = Rcpp::wrap(data.precursorCharge);

+        names.push_back("precursorIntensity");

+        header[i++] = Rcpp::wrap(data.precursorIntensity);

+        names.push_back("mergedScan");

+        header[i++] = Rcpp::wrap(data.mergedScan);

+        names.push_back("mergedResultScanNum");

+        header[i++] = Rcpp::wrap(data.mergedResultScanNum);

+        names.push_back("mergedResultStartScanNum");

+        header[i++] = Rcpp::wrap(data.mergedResultStartScanNum);

+        names.push_back("mergedResultEndScanNum");

+        header[i++] = Rcpp::wrap(data.mergedResultEndScanNum);

+        header.attr("names") = names;

         return  header;

     }

@@ -215,11 +229,6 @@ Rcpp::DataFrame RcppRamp::getAllScanHeaderInfo ( )

             Rcpp::NumericVector precursorMZ(N);  /* only if MS level > 1 */

             Rcpp::IntegerVector precursorCharge(N);  /* only if MS level > 1 */

             Rcpp::NumericVector precursorIntensity(N);  /* only if MS level > 1 */

-            // char scanType[SCANTYPE_LENGTH];

-            // char activationMethod[SCANTYPE_LENGTH];

-            // char possibleCharges[SCANTYPE_LENGTH];

-            // int numPossibleCharges;

-            // bool possibleChargesArray[CHARGEARRAY_LENGTH]; /* NOTE: does NOT include "precursorCharge" information; only from "possibleCharges" */

             Rcpp::IntegerVector mergedScan(N);  /* only if MS level > 1 */

             Rcpp::IntegerVector mergedResultScanNum(N); /* scan number of the resultant merged scan */

             Rcpp::IntegerVector mergedResultStartScanNum(N); /* smallest scan number of the scanOrigin for merged scan */

@@ -251,35 +260,56 @@ Rcpp::DataFrame RcppRamp::getAllScanHeaderInfo ( )

                 mergedResultEndScanNum[whichScan-1] = scanHeader.mergedResultEndScanNum;

             }

-            ListBuilder header;

-            header.add("seqNum", seqNum);

-            header.add("acquisitionNum",           acquisitionNum);

-            header.add("msLevel",                  msLevel);

-            header.add("polarity",               polarity);

-            header.add("peaksCount",               peaksCount);

-            header.add("totIonCurrent",            totIonCurrent);

-            header.add("retentionTime",            retentionTime);

-            header.add("basePeakMZ",               basePeakMZ);

-            header.add("basePeakIntensity",        basePeakIntensity);

-            header.add("collisionEnergy",          collisionEnergy);

-            header.add("ionisationEnergy",         ionisationEnergy);

-            header.add("lowMZ",                    lowMZ);

-            header.add("highMZ",                   highMZ);

-            header.add("precursorScanNum",         precursorScanNum);

-            header.add("precursorMZ",              precursorMZ);

-            header.add("precursorCharge",          precursorCharge);

-            header.add("precursorIntensity",       precursorIntensity);

-            //  header.add("scanType",                 scanType);

-            //  header.add("activationMethod",         activationMethod);

-            //  header.add("possibleCharges",          possibleCharges);

-            //  header.add("numPossibleCharges",       numPossibleCharges);

-            //  header.add("possibleChargesArray",     possibleChargesArray);

-            header.add("mergedScan",               mergedScan);

-            header.add("mergedResultScanNum",      mergedResultScanNum);

-            header.add("mergedResultStartScanNum", mergedResultStartScanNum);

-            header.add("mergedResultEndScanNum",   mergedResultEndScanNum);

+            Rcpp::List header(21);

+            std::vector<std::string> names;

+            int i = 0;

-            allScanHeaderInfo = header.get();

+            names.push_back("seqNum");

+            header[i++] =Rcpp::wrap(seqNum);

+            names.push_back("acquisitionNum");

+            header[i++] =Rcpp::wrap( acquisitionNum);

+            names.push_back("msLevel");

+            header[i++] =Rcpp::wrap(msLevel);

+            names.push_back("polarity");

+            header[i++] =Rcpp::wrap(polarity);

+            names.push_back("peaksCount");

+            header[i++] =Rcpp::wrap(peaksCount);

+            names.push_back("totIonCurrent");

+            header[i++] =Rcpp::wrap(totIonCurrent);

+            names.push_back("retentionTime");

+            header[i++] =Rcpp::wrap(retentionTime);

+            names.push_back("basePeakMZ");

+            header[i++] =Rcpp::wrap(basePeakMZ);

+            names.push_back("basePeakIntensity");

+            header[i++] =Rcpp::wrap(basePeakIntensity);

+            names.push_back("collisionEnergy");

+            header[i++] =Rcpp::wrap(collisionEnergy);

+            names.push_back("ionisationEnergy");

+            header[i++] =Rcpp::wrap(ionisationEnergy);

+            names.push_back("lowMZ");

+            header[i++] =Rcpp::wrap(lowMZ);

+            names.push_back("highMZ");

+            header[i++] =Rcpp::wrap(highMZ);

+            names.push_back("precursorScanNum");

+            header[i++] =Rcpp::wrap(precursorScanNum);

+            names.push_back("precursorMZ");

+            header[i++] =Rcpp::wrap(precursorMZ);

+            names.push_back("precursorCharge");

+            header[i++] =Rcpp::wrap(precursorCharge);

+            names.push_back("precursorIntensity");

+            header[i++] =Rcpp::wrap(precursorIntensity);

+            names.push_back("mergedScan");

+            header[i++] =Rcpp::wrap(mergedScan);

+            names.push_back("mergedResultScanNum");

+            header[i++] =Rcpp::wrap(mergedResultScanNum);

+            names.push_back("mergedResultStartScanNum");

+            header[i++] =Rcpp::wrap(mergedResultStartScanNum);

+            names.push_back("mergedResultEndScanNum");

+            header[i++] =Rcpp::wrap(mergedResultEndScanNum);

+            

+			header.attr("names") = names;

+			

+            allScanHeaderInfo = header;

             isInCacheAllScanHeaderInfo = TRUE;

         }

         else