Esempio n. 1
0
int backupfile(const std::string& filename, const std::string& backupname, int renamelevels){
    std::fstream file(filename.c_str(),std::ios::in|std::ios::binary);
    if (!file.is_open()){
        return -1;
    }
    ulti::mkdir(ulti::parentFolder(backupname).name,true);
    std::fstream fback;
    bool g2g = 0;
    int tries = 0;
    if (renamelevels>1){
        for(int a = 0; a < renamelevels; a++){
            std::stringstream ss(backupname);
            ss << backupname << ".back(" << a << ")";
            fback.open(ss.str().c_str(),std::ios::in|std::ios::binary);
            if (!fback.is_open()){
                fback.close();
                fback.open(ss.str().c_str(),std::ios::out|std::ios::binary);
                if (!fback.is_open()){
                    continue;
                }
                fback << file.rdbuf();
                std::stringstream ss2(backupname);
                ss2 << backupname << ".back(" << (a+1)%renamelevels << ")";
                remove(ss2.str().c_str());
                g2g=1;
                break;
            }
            else{
                fback.close();
                if (a == renamelevels-1 && tries == 0){
                    std::stringstream ss2(backupname);
                    ss2 << backupname << ".back(" << 0 << ")";
                    remove(ss2.str().c_str());
                    tries++;
                    a=-1;
                    continue;
                }
            }
        }
    }
    else{
        std::stringstream ss(backupname);
        ss << backupname << ".backup";
        fback.open(ss.str().c_str(),std::ios::out|std::ios::binary);
        if (fback.is_open()){
            fback << file.rdbuf();
            g2g=1;
        }
    }
    file.close();
    fback.close();
    if (!g2g){
        return -2;
    }
    return 1;
}
Esempio n. 2
0
bool CMessageCrypter::Decrypt(const string& vchPrivKey, const string& vchCiphertext, string& vchPlaintext)
{
    try
    {
        AutoSeededRandomPool prng;

        StringSource ss(vchPrivKey, true /*pumpAll*/);

        Integer x;
        x.Decode(ss, ss.MaxRetrievable(), Integer::UNSIGNED);

        ECIES<ECP>::Decryptor decryptor;

		decryptor.AccessKey().AccessGroupParameters().Initialize(ASN1::secp256k1());	
        //make decryptor's access key using decoded private exponent's value
        decryptor.AccessKey().SetPrivateExponent(x);

        //check whether decryptor's access key is valid or not
        bool valid = decryptor.AccessKey().Validate(prng, 3);
        if(!valid)
           decryptor.AccessKey().ThrowIfInvalid(prng, 3);

        //decrypt the message using private key
        StringSource ss2 (vchCiphertext, true, new PK_DecryptorFilter(prng, decryptor, new StringSink(vchPlaintext) ) );

    }
    catch(const CryptoPP::Exception& ex)
    {
		return false;
    }
    return true;
}
Esempio n. 3
0
//
// Deterministically calculate a given "score" for a Masternode depending on how close it's hash is to
// the proof of work for that block. The further away they are the better, the furthest will win the election
// and get paid this block
//
uint256 CMasternode::CalculateScore(int mod, int64_t nBlockHeight)
{
    if(chainActive.Tip() == NULL) return 0;

    uint256 hash = 0;
    uint256 aux = vin.prevout.hash + vin.prevout.n;

    if(!GetBlockHash(hash, nBlockHeight)) {
        LogPrintf("CalculateScore ERROR - nHeight %d - Returned 0\n", nBlockHeight);
        return 0;
    }

    CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
    ss << hash;
    uint256 hash2 = ss.GetHash();

    CHashWriter ss2(SER_GETHASH, PROTOCOL_VERSION);
    ss2 << hash;
    ss2 << aux;
    uint256 hash3 = ss2.GetHash();

    uint256 r = (hash3 > hash2 ? hash3 - hash2 : hash2 - hash3);

    return r;
}
Esempio n. 4
0
 void test() {
     const pretype& const_pre_vector = pre_vector;
     local_check_equal(real_vector.size(), pre_vector.size());
     local_check_equal(real_vector.empty(), pre_vector.empty());
     for (Size s = 0; s < real_vector.size(); s++) {
          local_check(real_vector[s] == pre_vector[s]);
          local_check(&(pre_vector[s]) == &(pre_vector.begin()[s]));
          local_check(&(pre_vector[s]) == &*(pre_vector.begin() + s));
          local_check(&(pre_vector[s]) == &*((pre_vector.end() + s) - real_vector.size()));
     }
     // local_check(realtype(pre_vector) == real_vector);
     local_check(pretype(real_vector.begin(), real_vector.end()) == pre_vector);
     local_check(pretype(pre_vector.begin(), pre_vector.end()) == pre_vector);
     size_t pos = 0;
     for (const T& v : pre_vector) {
          local_check(v == real_vector[pos++]);
     }
     for (const T& v : reverse_iterate(pre_vector)) {
          local_check(v == real_vector[--pos]);
     }
     for (const T& v : const_pre_vector) {
          local_check(v == real_vector[pos++]);
     }
     for (const T& v : reverse_iterate(const_pre_vector)) {
          local_check(v == real_vector[--pos]);
     }
     CDataStream ss1(SER_DISK, 0);
     CDataStream ss2(SER_DISK, 0);
     ss1 << real_vector;
     ss2 << pre_vector;
     local_check_equal(ss1.size(), ss2.size());
     for (Size s = 0; s < ss1.size(); s++) {
         local_check_equal(ss1[s], ss2[s]);
     }
 }
Esempio n. 5
0
void CSVMap::ConstructMap()
{
    ifstream csvFile;
    csvFile.open(file_path_.c_str());

    if(csvFile.is_open())
    {
        string line;

        istringstream s(line);

        if(this->header_)
        {
            string header;

            //Record and skip header
            if(getline(csvFile, line))
            {
                istringstream ss(line);

                while(getline(ss, header, ','))
                    this->headers_.push_back(header);
            }
        }

        while(getline(csvFile, line))
        {
            istringstream ss(line);

            string column;
            Date* key_date = NULL;
            while(getline(ss, column, ','))
            {
                if(key_date == NULL)
                {
                    int string_date[3];
                    string splitdate;
                    int count = 0;
                    istringstream ss2(column);

                    while(getline(ss2, splitdate, '/'))
                    {
                        string_date[count] = atoi(splitdate.c_str());
                        count++;
                    }

                    key_date = new Date(string_date[0], string_date[1], string_date[2]);
                }
                else
                    this->csvmap_[*key_date].push_back(column);
            }

            delete key_date;
        }
    }
    else
        cout << "File not found.\n";

    csvFile.close();
}
Esempio n. 6
0
void unmap_path(string path, string fileid) {
  //cout << "in unmap_path" << endl;
  //cout << "path: " << path << " fileid: " << fileid << endl;
  string token = "";
  string attr = "";
  stringstream ss2(path.c_str());
  while(getline(ss2, token, '/')) {
    //cout << "got token " << token << endl;
    if(strcmp(token.c_str(),"null")!=0) {
      if(attr.length()>0) {
        //cout << "removing map " << attr << " to " << token << endl;
        database_remove_val(fileid, attr, token);
        if(attr=="location") {
          int pos=find(server_ids.begin(),server_ids.end(),token)-server_ids.begin();
          if( pos < server_ids.size() ) {
            database_remove_val(fileid, "server", servers.at(pos));
          }
        }
        attr = "";
      } else {
        attr = token;
      }
    }
  }
  //cout << "finished unmap_path" << endl << endl;
}
Esempio n. 7
0
static int xmp_unlink(const char *path) {
  //log_msg("in xmp_unlink");
  //TODO: handle in vold somehow
  int res;
  string fileid=database_getval("name",basename(strdup(path)));

    string fromext=database_getval(fileid,"ext");
    string file=append_path2(basename(strdup(path)));
    string attrs=database_getval(fromext,"attrs");
    //cout << fromext <<  fileid << endl;
    //cout<<"HERE!"<<endl;
    database_remove_val(fileid,"attrs","all_"+fromext+"s");
    //cout<<"THERE!"<<endl;
    //database_remove_val("all_"+fromext+"s",strdup(basename(strdup(from))),fileid);
    //cout<<"WHERE!"<<endl;
    string token="";
    stringstream ss2(attrs.c_str());
    while(getline(ss2,token,':')){
      if(strcmp(token.c_str(),"null")!=0){
        string cmd=database_getval(token+"gen","command");
        string msg2=(cmd+" "+file).c_str();
        FILE* stream=popen(msg2.c_str(),"r");
        if(fgets(msg,200,stream)!=0){
          database_remove_val(fileid,token,msg);
        }
                                pclose(stream);
      }
    }

        path=append_path2(basename(strdup(path)));
        res = unlink(path);
  if (res == -1)
    return -errno;
  return 0;
}
Esempio n. 8
0
void process_file(string server, string fileid) {
  string file = database_getval(fileid, "name");
  string ext = database_getval(fileid, "ext");
  file = server + "/" + file;
  string attrs=database_getval(ext,"attrs");
  string token="";
  stringstream ss2(attrs.c_str());
  while(getline(ss2,token,':')){
    if(strcmp(token.c_str(),"null")!=0){
      if(token == "name") {
        continue;
      }
      //cout << "========= looking at attr =   " << token <<endl;
      string cmd=database_getval(token+"gen","command");
      if(cmd=="null") {
        //cout << "command is null, skipping" << endl;
        continue;
      }
      string msg2=(cmd+" \""+file+"\"").c_str();
      //cout << "========= issuing command =   " << msg2 <<endl;
      FILE* stream=popen(msg2.c_str(),"r");
      if(fgets(msg,200,stream)!=0){
        //cout << "========= attr value =   " << msg <<endl;
        database_setval(fileid,token,msg);
      }
      pclose(stream);
    }
  }
}
Esempio n. 9
0
/**
 * @function sendMsg
 */
bool sendMsg( BYTE _buf[BUFFER_SIZE] ) {

  // Cast as char*
  std::string text( (char*)_buf );

  // Read lines
  std::vector<pos> values;
  std::stringstream ss( text );
  std::string line;
  
  while( true ) {
    std::getline(ss, line);
    if( ss.eof() ) { break; }
    std::stringstream ss2(line);
    pos p;
    ss2 >> p.id >> p.x >> p.y >> p.z >> p.qw >> p.qx >> p.qy >> p.qz;
    values.push_back(p);
    
  }
  
  // Send msg
  sns_msg_tracker* msg;
  msg = sns_msg_tracker_alloc( values.size() );
  msg->header.n = values.size();
  for( int i = 0; i < msg->header.n; ++i ) {
    msg->u[i].x = values[i].x; msg->u[i].y = values[i].y; msg->u[i].z = values[i].z;
    msg->u[i].qx = values[i].qx; msg->u[i].qy = values[i].qy;
    msg->u[i].qz = values[i].qz; msg->u[i].qw = values[i].qw;
    msg->u[i].id = values[i].id;
  }

  return ( ach_put( &chan, msg, sns_msg_tracker_size( msg ) ) == ACH_OK );
}
Esempio n. 10
0
void subtractBackground(const TString conf){

  std::cout << "conf=" << conf << "\n";

  // Read from configuration file only the location of the root files
  TString inputDir;
  Double_t lumi;
  Bool_t doWeight;
  ifstream ifs;
  ifs.open(conf.Data());
  if (!ifs.is_open()) {
    std::cout << "failed to open file <" << conf << ">\n";
    assert(ifs.is_open());
  }

  string line;
  vector<TString>  snamev;    // sample name (for output file)
  vector<CSample*> samplev;   // data/MC samples
  Int_t state=0;
  while(getline(ifs,line)) {
    if(line[0]=='#') continue;
    if(line[0]=='%') { 
      state++; 
      continue; 
    }
    if(line[0]=='$') {
      samplev.push_back(new CSample());
      stringstream ss(line);
      string chr;
      string sname;
      Int_t color;
      ss >> chr >> sname >> color;
      string label = line.substr(line.find('@')+1);
      snamev.push_back(sname);
      samplev.back()->label = label;
      samplev.back()->color = color;
      continue;
    }
    
    if(state==0) {  // general settings
      stringstream ss1(line); ss1 >> lumi;
      getline(ifs,line);
      stringstream ss2(line); ss2 >> doWeight;
      getline(ifs,line);
      inputDir = TString(line);
      getline(ifs,line);
      // backwards compatibility for the input file
      if (line.size()>3) {  // escale is defined
	TString escaleTag_loc=TString(line);
	getline(ifs,line);
	// check that it was correct to use this work-around
	if (line.find('%')!=std::string::npos) {
	  std::cout << "backwards-compatibility code failure\n";
	  return;
	}
      }
      TString format_loc = TString(line);
      
    } else if(state==1) {  // define data sample
Esempio n. 11
0
void selectEleBDTGWithIPInfoEffTP(const TString conf,              // input file
                      const TString outputDir,         // output directory
		      const Bool_t  matchGen = kFALSE  // match to generator muons
) {
  gBenchmark->Start("selectEleLHEffTP");

  //--------------------------------------------------------------------------------------------------------------
  // Settings 
  //============================================================================================================== 

  //*****************************************************************************************
  //Setup MVA
  //*****************************************************************************************
  mithep::ElectronIDMVA *electronIDMVAWithIPInfo = new mithep::ElectronIDMVA();
  electronIDMVAWithIPInfo->Initialize("BDTG method",
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet0LowPt_WithIPInfo_BDTG.weights.xml", 
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet1LowPt_WithIPInfo_BDTG.weights.xml", 
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet2LowPt_WithIPInfo_BDTG.weights.xml", 
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet0HighPt_WithIPInfo_BDTG.weights.xml", 
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet1HighPt_WithIPInfo_BDTG.weights.xml", 
                              "/home/sixie/CMSSW_analysis/src/MitPhysics/data/ElectronMVAWeights/Subdet2HighPt_WithIPInfo_BDTG.weights.xml",
                              mithep::ElectronIDMVA::kWithIPInfo);

  // mass region
  Double_t massLo;
  Double_t massHi;

  Double_t lumi;              // luminosity (pb^-1)
  
  vector<TString>  fnamev;    // sample files
  vector<Int_t>    typev;     // dataset type 
  vector<Double_t> xsecv;     // per file cross section
  vector<TString>  jsonv;     // per file JSON file

  //
  // parse .conf file
  //
  ifstream ifs;
  ifs.open(conf.Data());
  assert(ifs.is_open());
  string line;
  Int_t state=0;
  while(getline(ifs,line)) {
    if(line[0]=='#') continue;
    if(line[0]=='%') { 
      state++; 
      continue; 
    }
    
    if(state==0) {  // general settings
      stringstream ss1(line); ss1 >> lumi;
      getline(ifs,line);
      stringstream ss2(line); ss2 >> massLo >> massHi; 
      
    } else if(state==1) {  // define data sample
Esempio n. 12
0
void OutfitWindow::load(const bool oldConfig)
{
    const Configuration *cfg;
    if (oldConfig)
        cfg = &config;
    else
        cfg = &serverConfig;

    memset(mItems, -1, sizeof(mItems));
    memset(mItemColors, 1, sizeof(mItemColors));

    for (unsigned o = 0; o < OUTFITS_COUNT; o++)
    {
        std::string outfit = cfg->getValue("Outfit" + toString(o), "-1");
        std::string buf;
        std::stringstream ss(outfit);

        std::vector<int> tokens;

        while (ss >> buf)
            tokens.push_back(atoi(buf.c_str()));

        for (size_t i = 0, sz = tokens.size();
             i < sz && i < OUTFIT_ITEM_COUNT; i++)
        {
            mItems[o][i] = tokens[i];
        }

        outfit = cfg->getValue("OutfitColor" + toString(o), "1");
        std::stringstream ss2(outfit);

        tokens.clear();

        std::vector<unsigned char> tokens2;
        while (ss2 >> buf)
            tokens2.push_back(static_cast<unsigned char>(atoi(buf.c_str())));

        for (size_t i = 0, sz = tokens2.size();
             i < sz && i < OUTFIT_ITEM_COUNT; i++)
        {
            mItemColors[o][i] = tokens2[i];
        }

        mItemsUnequip[o] = cfg->getValueBool("OutfitUnequip" + toString(o),
                                             true);
    }
    mAwayOutfit = cfg->getValue("OutfitAwayIndex", OUTFITS_COUNT - 1);
    if (mAwayOutfit >= static_cast<int>(OUTFITS_COUNT))
        mAwayOutfit = static_cast<int>(OUTFITS_COUNT) - 1;

    if (mAwayOutfitCheck)
        mAwayOutfitCheck->setSelected(mAwayOutfit == mCurrentOutfit);
}
Esempio n. 13
0
void Rig::loadJSON(JSONNode root) {
  //JSONNode::const_iterator i = root.begin();
  JSONNode::iterator i = root.begin();

  auto version = root.find("version");
  if (version == root.end()) {
    Logger::log(ERR, "No version specified for input file. Aborting load.");
    return;
  }
  else {
    stringstream ss;
    stringstream ss2(version->as_string());

    ss << LumiverseCore_VERSION_MAJOR << "." << LumiverseCore_VERSION_MINOR;
    
    float libVer;
    float fileVer;

    ss >> libVer;
    ss2 >> fileVer;

    if (fileVer < libVer) {
      // Friendly warning if you're loading an old file.
      Logger::log(WARN, "File created against earlier version of Lumiverse. Check logs for any load problems.");
    }
    else if (fileVer > libVer) {
      // Loading newer file with older library.
      Logger::log(WARN, "File created against newer version of Lumiverse. Check logs for any load problems.");
    }
  }

  while (i != root.end()){
    // get the node name and value as a string
    std::string nodeName = i->name();

    if (nodeName == "devices") {
      loadDevices(*i);
      Logger::log(INFO, "Device load complete");
    }
    else if (nodeName == "patches") {
	  i->push_back(*root.find("jsonPath"));
      loadPatches(*i);
      Logger::log(INFO, "Patch load complete");
    }
    else if (nodeName == "refreshRate") {
      setRefreshRate(i->as_int());
    }

    //increment the iterator
    ++i;
  }
}
TString subtractBackground(const TString conf,
		   DYTools::TSystematicsStudy_t runMode=DYTools::NORMAL,
			   const TString plotsDirExtraTag="",
			   int performPUReweight=1){


  std::cout << "\n\nRun mode: " << SystematicsStudyName(runMode) << "\n";
  switch(runMode) {
  case DYTools::NORMAL:
  case DYTools::ESCALE_STUDY:
  case DYTools::ESCALE_STUDY_RND:
    break;
  default:
    std::cout << "subtractBackground is not ready for runMode=" << SystematicsStudyName(runMode) << "\n";
    throw 2;
  }
 
  //--------------------------------------------------------------------------------------------------------------
  // Settings 
  //==============================================================================================================

  // Read from configuration file only the location of the root files
  TString inputDir;
  Double_t lumi;
  Bool_t doWeight;
  Bool_t hasData=false;

  ifstream ifs;
  ifs.open(conf.Data());
  assert(ifs.is_open());
  string line;
  int state=0;
  while(getline(ifs,line)) {
    if(line[0]=='#') continue;
    if(line[0]=='%') { 
      state++; 
      continue; 
    }
    if(state==0) {
      stringstream ss1(line); ss1 >> lumi;
      getline(ifs,line);
      stringstream ss2(line); ss2 >> doWeight;
      getline(ifs,line);
      inputDir = TString(line);
      TString escaleTag_loc,format_loc;
      getline(ifs,line);
      stringstream ss3(line); ss3 >> escaleTag_loc;
      getline(ifs,line);
      format_loc = TString(line);
      state++;
    }
    else if (state==1) {
Esempio n. 15
0
int CAddrInfo::GetNewBucket(const uint256& nKey, const CNetAddr& src) const
{
    CDataStream ss1(SER_GETHASH, 0);
    std::vector<unsigned char> vchGroupKey = GetGroup();
    std::vector<unsigned char> vchSourceGroupKey = src.GetGroup();
    ss1 << nKey << vchGroupKey << vchSourceGroupKey;
    uint64_t hash1 = Hash(ss1.begin(), ss1.end()).GetLow64();

    CDataStream ss2(SER_GETHASH, 0);
    ss2 << nKey << vchSourceGroupKey << (hash1 % ADDRMAN_NEW_BUCKETS_PER_SOURCE_GROUP);
    uint64_t hash2 = Hash(ss2.begin(), ss2.end()).GetLow64();
    return hash2 % ADDRMAN_NEW_BUCKET_COUNT;
}
Esempio n. 16
0
int CAddrInfo::GetTriedBucket(const uint256& nKey) const
{
    CDataStream ss1(SER_GETHASH, 0);
    std::vector<unsigned char> vchKey = GetKey();
    ss1 << nKey << vchKey;
    uint64_t hash1 = Hash(ss1.begin(), ss1.end()).GetLow64();

    CDataStream ss2(SER_GETHASH, 0);
    std::vector<unsigned char> vchGroupKey = GetGroup();
    ss2 << nKey << vchGroupKey << (hash1 % ADDRMAN_TRIED_BUCKETS_PER_GROUP);
    uint64_t hash2 = Hash(ss2.begin(), ss2.end()).GetLow64();
    return hash2 % ADDRMAN_TRIED_BUCKET_COUNT;
}
Esempio n. 17
0
File: Chunk.cpp Progetto: Cmdu76/Map
bool Chunk::load()
{
    std::ifstream file(getPathFromCoords(mCoords));
    if (!file)
    {
        return false;
    }

    std::string line;
    std::size_t layerCount;
    std::getline(file,line);
    {
        std::istringstream iss(line);
        iss >> layerCount;
    }
    for (std::size_t i = 0; i < layerCount; i++)
    {
        addLayer();
    }

    sf::Vector2i coords = sf::Vector2i();
    int z = 0;
    while (std::getline(file,line))
    {
        std::stringstream ss1(line);
        std::string temp1;
        coords.x = 0;
        while (std::getline(ss1,temp1,';'))
        {
            std::stringstream ss2(temp1);
            std::string temp2;
            z = 0;
            while (std::getline(ss2,temp2,'-'))
            {
                int id;
                {
                    std::istringstream iss(temp2);
                    iss >> id;
                }
                setTileId(coords,z,id);
                z++;
            }
            coords.x++;
        }
        coords.y++;
    }
    file.close();
    mNeedSave = false;
    return true;
}
Esempio n. 18
0
//
// Deterministically calculate a given "score" for a Masternode depending on how close it's hash is to
// the proof of work for that block. The further away they are the better, the furthest will win the election
// and get paid this block
//
arith_uint256 CMasternode::CalculateScore(const uint256& blockHash)
{
    uint256 aux = ArithToUint256(UintToArith256(vin.prevout.hash) + vin.prevout.n);

    CHashWriter ss(SER_GETHASH, PROTOCOL_VERSION);
    ss << blockHash;
    arith_uint256 hash2 = UintToArith256(ss.GetHash());

    CHashWriter ss2(SER_GETHASH, PROTOCOL_VERSION);
    ss2 << blockHash;
    ss2 << aux;
    arith_uint256 hash3 = UintToArith256(ss2.GetHash());

    return (hash3 > hash2 ? hash3 - hash2 : hash2 - hash3);
}
void verticesGraph::buildGraph(char * fileName)
{
    milesTraveled = 0;
    std::string firstLine,lines;
    std::string itemArray[20][20];
    int m=0,quantity=0;
    std::ifstream inFile;
    inFile.open(fileName);
    if(inFile.good())
    {
        getline(inFile,firstLine);
        std::stringstream ss1(firstLine);
        std::string items1;
        while(getline(ss1,items1,','))
        {
            quantity+=1;
        }
        quantity-=1;
        while(getline(inFile,lines))
        {
            int n=0;
            std::stringstream ss2(lines);
            std::string items2;
            while(getline(ss2,items2,','))
            {
                itemArray[m][n]=items2;
                n+=1;
            }
            m+=1;
        }
    }

    for(int m=0;m<quantity;m++)
    {
        addVertex(itemArray[m][0]);
    }

    for(int m=0;m<quantity;m++)
    {
        for(int n=0;n<quantity;n++)
        {
            if(itemArray[m][n+1]!="-1"&&itemArray[m][n+1]!="0")
            {
                addEdge(itemArray[m][0],itemArray[n][0],atoi(itemArray[m][n+1].c_str()));
            }
        }
    }
}
Esempio n. 20
0
/**
 * @brief Decrypts input string stream using AES in GCM mode for
 *        confidentiality and authenticity.
 *
 * @param cipher const reference to a byte vector with encrypted data.
 * @param messageData reference to a byte vector to hold decrypted data.
 * @param key const reference to a byte vector with the decryption key.
 *
 * @return true, if decryption is successful.
 */
bool FileCryptopp::decrypt(
    const std::vector<uint8_t>& cipher,
    std::vector<uint8_t>& messageData,
    const std::vector<uint8_t>& key
) {

    // Initial Vector (IV) for AES to XOR.
    std::vector<uint8_t> iv(CryptoPP::AES::BLOCKSIZE);

    std::string decryptedtext; // store decrypted message


    try {
        // Initialize AES.
        CryptoPP::GCM< AES >::Decryption e;

        // Set AES Key and load IV.
        e.SetKeyWithIV(key.data(), key.size(), iv.data());

        /* Load encrypted data into an array source, then decrypt data using
         * a transformation filter. Dump the transformation using a string
         * sink into decryptedtext.
         */
        ArraySource ss2(
            cipher.data(),
            cipher.size(),
            true,
            new CryptoPP::AuthenticatedDecryptionFilter(
                e,
                new StringSink(decryptedtext)
            ) // StreamTransformationFilter
        ); // StringSource

    } catch (const CryptoPP::Exception& e) {
        // Failed decryption.
        std::cerr << "Error decrypting file: " << e.what() << std::endl;
        return false;
    }

    // Append messageData with bytes from decryptedtext.
    for (int i = 0; i < decryptedtext.size(); i++) {
        messageData.push_back(
            0xFF & static_cast<uint8_t>(decryptedtext[i])
        );
    }

    return true;
}
Esempio n. 21
0
void selectSingleMuTrigEffTP(const TString conf,              // input file
                         const TString outputDir,         // output directory
                         Int_t RunRange = 0,              // Run Range
		         const Bool_t  matchGen = kFALSE  // match to generator muons
) {
  gBenchmark->Start("selectSingleMuEffTP");

  //--------------------------------------------------------------------------------------------------------------
  // Settings 
  //============================================================================================================== 
  
  // mass region
  Double_t massLo;
  Double_t massHi;

  Double_t lumi;              // luminosity (pb^-1)
  
  vector<TString>  fnamev;    // sample files 
  vector<Int_t>    typev;     // dataset type 
  vector<Double_t> xsecv;     // per file cross section
  vector<TString>  jsonv;     // per file JSON file

  //
  // parse .conf file
  //
  ifstream ifs;
  ifs.open(conf.Data());
  assert(ifs.is_open());
  string line;
  Int_t state=0;
  while(getline(ifs,line)) {
    if(line[0]=='#') continue;
    if(line[0]=='%') { 
      state++; 
      continue; 
    }
    
    if(state==0) {  // general settings
      stringstream ss1(line); ss1 >> lumi;
      getline(ifs,line);
      stringstream ss2(line); ss2 >> massLo >> massHi; 
      
    } else if(state==1) {  // define data sample
Esempio n. 22
0
void Test::LoadAnswers()
{
	std::string buffer, number;
	std::ifstream file;

	file.open("../Data/Answers.csv");
	if (!file.is_open())
		throw std::exception("Error: file(Question.csv) is not opened!\n");

	int question_num;
	while (!file.eof())
	{
		std::getline(file, buffer);
		std::vector<std::string> data = ParseCSVString(buffer);
		if (!data.size())
			break;

		number = data[0];
		std::stringstream ss(number);
		ss >> question_num;

		Answer answer(data[1]);
		for (auto it = data.begin() + 2; it != data.end(); it++)
		{
			// read trait number
			int trait_, score_;
			number = *it;
			std::stringstream ss1(number);
			ss1 >> trait_;

			//read score
			it++;

			number = *it;
			std::stringstream ss2(number);
			ss2 >> score_;
			answer.AddPoint(trait_, score_);
		}
		questions[question_num].answers.push_back(answer);
	}
	file.close();
}
TEST_F(LoadPlanningModelsPr2, StateSpaces)
{
  ompl_interface::ModelBasedStateSpaceSpecification spec1(kmodel_, "right_arm");
  ompl_interface::ModelBasedStateSpace ss1(spec1);
  ss1.setup();

  ompl_interface::ModelBasedStateSpaceSpecification spec2(kmodel_, "left_arm");
  ompl_interface::ModelBasedStateSpace ss2(spec2);
  ss2.setup();

  ompl_interface::ModelBasedStateSpaceSpecification spec3(kmodel_, "whole_body");
  ompl_interface::ModelBasedStateSpace ss3(spec3);
  ss3.setup();

  ompl_interface::ModelBasedStateSpaceSpecification spec4(kmodel_, "arms");
  ompl_interface::ModelBasedStateSpace ss4(spec4);
  ss4.setup();
  
  std::ofstream fout("ompl_interface_test_state_space_diagram2.dot");
  ompl::base::StateSpace::Diagram(fout);
}
Esempio n. 24
0
  //---------------------------------------------------------------------------
  QString fileload(QVector<aln::s_inp> &vOrgSeq, QString alnfile, int &nrErrors)
  {

     QString fileName = alnfile;
     QVector <aln::s_inp> NN = vOrgSeq;
     int nn = nrErrors;
     nn++;

    //check file
    QFile file(fileName);

    if (!file.open(QIODevice::ReadOnly)) {
        return("ERROR - Could not open file!");
    }//if

    QString str2;
    QTextStream ss2(&str2);
    ss2 << "Aln File: " << fileName << endl;

    return (str2);
  }
    int compareVersion(string version1, string version2) {

      vector<int> v1, v2;
      int x;
      for (int i = 0; i < version1.size(); i++)
        if (version1[i] == '.') version1[i] = ' ';

      for (int i = 0; i < version2.size(); i++)
        if (version2[i] == '.') version2[i] = ' ';

      stringstream ss1(version1), ss2(version2);
      while (ss1 >> x) {
        v1.push_back(x);
      }
      while (ss2 >> x) {
        v2.push_back(x);
      }
      while (v1.size() > 0 && v1[v1.size() - 1] == 0 ) {
        if (v1[v1.size() - 1] == 0)
          v1.erase(v1.end() - 1);
      }
      while (v2.size() > 0 && v2[v2.size() - 1] == 0) {
        if (v2[v2.size() - 1] == 0)
          v2.erase(v2.end() - 1);
      }
      int i = 0, j = 0;
      for (; i < v1.size() && j < v2.size(); i++, j++) {
        if (v1[i] > v2[i])
          return 1;
        if (v2[i] > v1[i])
          return -1;
      }
      if (i < v1.size())
        return 1;
      if (j < v2.size())
        return -1;
      return 0;
    }
Esempio n. 26
0
int main(int argc, char *argv[])
{
	if( argc < 5 )
	{
		cerr << "Lack of args: need three args!" << endl;
		return -1;
	}

	ADDRINT nSizePower;
	stringstream ss(argv[1]);
	ss >> nSizePower;	
	cerr << "Memory Size (in bytes):\t" << hex << (1<<nSizePower) << dec << endl;	

	string szFile = argv[2];

	ADDRINT nLineSizeShift;
	stringstream ss1(argv[3]);
	ss1 >> nLineSizeShift;

	bool bStackAllocator = true;
	stringstream ss2(argv[4]);
	ss2 >> bStackAllocator;	

	
	

	CAllocator *allocator;

if(bStackAllocator)
	allocator = new CStackAllocator(nSizePower, nLineSizeShift, szFile);
else
	allocator = new CHeapAllocator(nSizePower, nLineSizeShift, szFile);


	allocator->run();
	return 0;
}
Esempio n. 27
0
  void RandomTree::_importOobSet(std::istream & fileStream)
  {
    if(fileStream.good())
    {
      std::string buffer;
      std::getline(fileStream, buffer);
      std::stringstream ss(buffer);
      std::string firstStr;
      std::string nextStr;
      unsigned int idx;
      ss >> firstStr;

      if(firstStr == "<OobSet>")
      {
        ss >> nextStr;

        while(nextStr != "</OobSet>")
        {
          std::stringstream ss2(nextStr);
          ss2 >> idx;
          _oobSet.push_back(idx);
          ss >> nextStr;
        }
      }
Esempio n. 28
0
int initializing_khan(char * mnt_dir) {
  //log_msg("In initialize\n");
  unmounting(mnt_dir);
      //Opening root directory and creating if not present
  //cout<<"khan_root[0] is "<<servers.at(0)<<endl;
  if(NULL == opendir(servers.at(0).c_str()))  {
    sprintf(msg,"Error msg on opening directory : %s\n",strerror(errno));
    //log_msg(msg);
    //log_msg("Root directory might not exist..Creating\n");
    string command = "mkdir " + servers.at(0);
    if (system(command.c_str()) < 0) {
      log_msg("Unable to create storage directory...Aborting\n");
      exit(1);
    }
  } else {
    fprintf(stderr, "directory opened successfully\n");
  }

  init_database();

  //check if we've loaded metadata before
  string output=database_getval("setup","value");
  if(output.compare("true")==0){
    log_msg("Database was previously initialized.");
    tot_time+=(stop.tv_sec-start.tv_sec)+(stop.tv_nsec-start.tv_nsec)/BILLION;
    return 0; //setup has happened before
  }

  //if we have not setup, do so now
  //log_msg("it hasnt happened, setvalue then setup");
  database_setval("setup","value","true");

  //load metadata associatons
  for(int i=0; i<servers.size(); i++){
    process_transducers(servers.at(i));
  }

  //load metadata for each file on each server
  string types=database_getval("allfiles","types");
  //cout << "================= types to look for ="<<types<<endl;
  for(int i=0; i<servers.size(); i++) {
    if(servers.at(i) == "cloud") {
      PyObject* myFunction = PyObject_GetAttrString(cloud_interface,(char*)"get_all_titles");
      PyObject* myResult = PyObject_CallObject(myFunction, NULL);
      if(myResult==NULL) {
        PyErr_PrintEx(0);
        continue;
      }
      int n = PyList_Size(myResult);
      //cout << "SIZE = " << n << endl << flush;
      for(int j = 0; j<n; j++) {
        PyObject* title = PyList_GetItem(myResult, j);
        char* temp = PyString_AsString(title);
        if(temp==NULL) {
          PyErr_PrintEx(0);
          continue;
        }
        string filename = temp;
        //cout << "Checking " << filename << " ... " << endl << flush;
        if(database_getval("name",filename)=="null") {
          string fileid = database_setval("null","name",filename);
          string ext = strrchr(filename.c_str(),'.')+1;
          database_setval(fileid,"ext",ext);
          database_setval(fileid,"server",servers.at(i));
          database_setval(fileid,"location",server_ids.at(i));
          string attrs=database_getval(ext,"attrs");
          string token="";
          stringstream ss2(attrs.c_str());
          PyObject* myFunction = PyObject_GetAttrString(cloud_interface,(char*)"get_metadata");
          while(getline(ss2,token,':')){
            if(strcmp(token.c_str(),"null")!=0){
              //cout << "========= looking at attr =   " << token << endl << flush;
              PyObject* arglist = PyTuple_New(2);
              PyTuple_SetItem(arglist, 0, PyString_FromString(filename.c_str()));
              PyTuple_SetItem(arglist, 1, PyString_FromString(token.c_str()));
              PyObject* myResult = PyObject_CallObject(myFunction, arglist);
              //cout << myResult << endl << flush;
              if(myResult==NULL) {
                PyErr_PrintEx(0);
                continue;
              }
              char* msg = PyString_AsString(myResult);
              if(!msg) {
                PyErr_PrintEx(0);
                continue;
              }
              string val = msg;
              Py_DECREF(arglist);
              Py_DECREF(myResult);
              //cout << "========= got val =   " << val << endl << flush;
              if(val!="na") {
                database_setval(fileid,token,val);
              }
            }
          }
        } else {
          string fileid = database_getval("name", filename);
          database_setval(fileid,"server",servers.at(i));
          database_setval(fileid,"location",server_ids.at(i));
        }
      } 
    } else {
      glob_t files;
      glob((servers.at(i)+"/*.*").c_str(),0,NULL,&files);
      for(int j=0; j<files.gl_pathc; j++) {//for each file
        string file = files.gl_pathv[j];
        string ext = strrchr(file.c_str(),'.')+1;
        string filename=strrchr(file.c_str(),'/')+1;
        if(database_getval("name", filename) == "null") {
          string fileid = database_setval("null","name",filename);
          database_setval(fileid,"ext",ext);
          database_setval(fileid,"server",servers.at(i));
          database_setval(fileid,"location",server_ids.at(i));
          for(int k=0; k<server_ids.size(); k++) {
            database_setval(fileid, server_ids.at(k), "0");
          }
          if(j%10==0) {
            cout << "processed file " << j << "\n";
          }
          process_file(servers.at(i), fileid);
        } else {
          string fileid = database_getval("name",filename);
          database_setval(fileid,"server",servers.at(i));
          database_setval(fileid,"location",server_ids.at(i));
        }
      }
    }
  }
  //log_msg("At the end of initialize\n");
  return 0;
}
Esempio n. 29
0
string Calculation::work()
{
    /*原理:后缀队列里面的front为符号时,弹出数字栈中的第一个元素a 第二个元素 b 运算顺序b+-a 再把结果入数字栈*/
    while(!num.empty())num.pop();
    while(!Suf.empty())
    {
        string t=Suf.front();
        Suf.pop();
        if(t=="")continue ;
        //cout<<t<<endl;
        if(t=="+"||t=="-"||t=="*"||t=="/")
        {
            double a;
            double b;
            string t1,t2;
            if(num.empty())t1+='0';//栈为空 就 为0 例如 -1000  == 0-1000
            else
            {
                t1=num.top();
                num.pop();
            }
            if(num.empty())t2+='0';
            else
            {
                t2=num.top();
                num.pop();
            }
            /*字符串转为数字*/
            stringstream ss(t1);
            ss>>a;
            stringstream ss2(t2);
            ss2>>b;
            //cout<<a<<" "<<b<<" "<<t<<endl;
            if(t=="+")
            {
                stringstream tostring;
                tostring<<a+b;
                //cout<<tostring.str()<<endl;
                num.push(tostring.str());
                /*数字转为字符串*/
            }
            if(t=="-")
            {
                stringstream tostring;
                tostring<<b-a;
                //cout<<tostring.str()<<endl;
                num.push(tostring.str());
            }
            if(t=="*")
            {
                stringstream tostring;
                tostring<<a*b;
                num.push(tostring.str());
            }
            if(t=="/")
            {
                stringstream tostring;
                tostring<<b/a;
                num.push(tostring.str());
            }
        }
        else
        {
Esempio n. 30
0
int main(int argc, char **argv)
{
	//You must call ros::init() first of all. ros::init() function needs to see argc and argv. The third argument is the name of the node
	ros::init(argc, argv, "PickerRobot");

	// convert input parameters for Robot initialization from String to respective types
	std::string xString = argv[1];
	std::string yString = argv[2];
	//theta is arg3
	std::string pickRangeString = argv[6];
	double xPos = atof(xString.c_str());
	double yPos = atof(yString.c_str());
	double pickRange = (atof(pickRangeString.c_str()))/2+0.1;
	ROS_INFO("x start: %f", xPos);
	ROS_INFO("y start: %f", yPos);
	ROS_INFO("pick range %f",pickRange);
	//assign start and finish beacons from input parameters of launch file
	std::string startString = argv[4];
	std::string finishString = argv[5];
	std::stringstream ss(startString);
	ss >> startBeacon;
	std::stringstream ss2(finishString);
	ss2 >> finishBeacon;
	currentBeacon = startBeacon;

	//initialize the Picker robot with the correct position, velocity and state parameters.
	pickerRobot = PickerRobot(xPos,yPos,M_PI/2,0,0,"To next beacon",pickRange);

	//NodeHandle is the main access point to communicate with ros.
	ros::NodeHandle n;

	//picker robot advertise it node for its velocity message to be published.
	pickerRobot.robotNode_stage_pub=n.advertise<geometry_msgs::Twist>("cmd_vel",1000);
	//picker robot advertise it node for its status message to be published.
	ros::Publisher pub=n.advertise<se306project::robot_status>("status",1000);

	//subscribe to listen to messages coming from stage about is position relative to absolute frame
	pickerRobot.stageOdo_Sub = n.subscribe<nav_msgs::Odometry>("base_pose_ground_truth",1000, callBackStageOdm);
	//subscribe to obstacle detection
	pickerRobot.baseScan_Sub = n.subscribe<sensor_msgs::LaserScan>("base_scan", 1000,callBackLaserScan);

	// publish weedobstacle
	pickerRobot.weed_obstacle_pub = n.advertise<se306project::weed_status>("weed",1000);

	//TODO need to subscribe to all carriers
	//subscribe to other carrier
	std::string carrierStart(argv[7]);
	std::string carrierEnd(argv[8]);
	int a = atoi(carrierStart.c_str());
	int b = atoi(carrierEnd.c_str());
	int size = b-a+1;
	std::string topicName="";
	//subscribing all the picker robot
	ros::Subscriber *carrierArray = new ros::Subscriber[size];
	int index = 0;
	for (int i = a; i<=b; i++) {
		std::stringstream convert;
		convert << i;
		topicName = "/robot_" + convert.str() + "/status";
		//subscribe to carrier robot's status message
		carrierArray[index] = n.subscribe<se306project::carrier_status>(topicName,1000,receiveCarrierRobotStatus);
		index++;
	}

	// assign beacon subscriber to the first beacon for this Picker robot's path.
	pickerRobot.subscribeNextBeacon(n);

	unsigned int num_readings = 100;
	double laser_frequency = 40;
	double ranges[num_readings];
	double intensities[num_readings];
	se306project::robot_status status_msg;
	ros::Rate loop_rate(10);

	//a count of howmany messages we have sent


	while (ros::ok())
	{
		int count = 0;
		//assign to status message
		status_msg.my_counter = count++;//add counter to message to broadcast
		status_msg.status=pickerRobot.getStatus();//add status to message to broadcast
		//status_msg.status ="Full";
		status_msg.pos_x=pickerRobot.getX(); //add x to message to broadcast
		status_msg.pos_y=pickerRobot.getY();//add y to message to broadcast
		status_msg.pos_theta=pickerRobot.getTheta(); //add angle to message to broadcast
		status_msg.obstacle = pickerRobot.getObstacleStatus();
		pub.publish(status_msg);//publish the message for other node

		pickerRobot.stateLogic(n);

		ros::spinOnce();
		loop_rate.sleep();
		++count;
	}

	delete[] carrierArray;
	return 0;
}