Parameters.C

Go to the documentation of this file.

#include "Parameters.H"


namespace ix {
  namespace util {

    util::ParamType *util::Parameters::ParamPtr(const std::string &key)
    {
      util::Parameters::const_iterator pi = this->begin();
      while(pi != this->end()){
        unsigned int index = pi - this->begin();
        if(pi->first == key)
          return(&((*this)[index]));
        pi++;
      }
      return(NULL);
    }
    
    std::string util::Parameters::GetValue(const std::string &key) const
    {
      return(this->Param(key));
      //       std::string retval(this->Param(key));
      //       std::string value(this->Param(key));
      //       if(!value.empty()){
      //        std::istringstream Istr(value);
      //        Istr >> retval;
      //       }
      //       return(retval);
    }

    std::vector<std::string> util::Parameters::GetValueVector(const std::string &key) const
    {
      std::vector<std::string> retval;
      std::string value(this->Param(key));
      if(!value.empty()){
        std::istringstream Istr(value);
        std::string tmpval;
        while(Istr >> tmpval)
          retval.push_back(tmpval);
      }
      return(retval);
    }

    std::istream &util::Parameters::ReadFromStream(std::istream &Is)
    {
      std::string streamLine;
      int n = 0;
      while(Is){
        streamLine.erase();
        std::getline(Is,streamLine);
        n++;
        if(streamLine.empty())
          continue;
        std::string lineToken;
        std::istringstream skipWhiteSpace(streamLine);
        std::ostringstream lineOut;
        while(skipWhiteSpace >> std::skipws >> lineToken)
          lineOut << lineToken << " ";
        std::string line(lineOut.str());
        
        std::string::size_type x = line.find('#');
        line = line.substr(0,x);
        if(!line.empty()){
          x = line.find('=');
          if(x == std::string::npos)
            return(Is);
          util::ParamType param;
          std::istringstream Instr(line.substr(0,x));
          Instr >> param.Key();
          std::vector<std::string> tokens;
          line = line.substr(x+1,line.size());
          TokenizeString(tokens,line);
          std::ostringstream Ostr;
          std::vector<std::string>::iterator ti = tokens.begin();
          if(ti != tokens.end())
            Ostr << *ti++;
          while(ti != tokens.end())
            Ostr << " " << *ti++;
          param.Value() = Ostr.str();
          this->push_back(param);
        }
      }
      return(Is);
    }

    std::string util::Parameters::Param(const std::string &key) const
    {
      std::string empty;
      util::Parameters::const_iterator pi = this->begin();
      while(pi != this->end()){
        if(pi->first == key){
          //           if((key.find("Fields") != std::string::npos) &&
          //              (pi->first.find("Fields") != std::string::npos)){
          //             std::cout << "\"" << key << "\" =MATCHES= \""
          //                       << pi->first << "\"" << std::endl;
          //           }
          return(pi->second);
        } else {
          //           if((key.find("Fields") != std::string::npos) &&
          //              (pi->first.find("Fields") != std::string::npos)){
          //             std::cout << "\"" << key << "\" =NOT= \""
          //                       << pi->first << "\"" << std::endl;
          //           }
        }
        pi++;
      }
      return(empty);
    }
  
    bool util::Parameters::IsSet(const std::string &key) const
    {
      return(!Param(key).empty());
    };
    

    std::ostream &util::Parameters::WriteToStream(std::ostream &oSt) const
    {
      util::Parameters::const_iterator pi = this->begin();
      while(pi != this->end()){
        oSt << *pi++;
        if(pi != this->end())
          oSt << std::endl;
      }
      return(oSt);
    };

    std::ostream &operator<<(std::ostream &oSt,
                             const util::Parameters &pv)
    {
      return(pv.WriteToStream(oSt));
    }
  
    std::istream &operator>>(std::istream &iSt,
                             util::Parameters &pv)
    {
      return(pv.ReadFromStream(iSt));
    }
  
  
    std::ostream &operator<<(std::ostream &Ostr,const util::ParamType &param)
    {
      Ostr << param.Key() << " = " << param.Value();
      return(Ostr);
    }

  };
};