---

ConfigBuffer.cpp

         /* ConfigBuffer.cpp  */


// Implementation of ConfigBuffer.h


#include"ConfigBuffer.h"

using namespace LcgConfigBuffer;

ConfigBuffer::ConfigBuffer(){}

ConfigBuffer::ConfigBuffer(const string& filename) {
this->populate_from_config(filename);
}


int ConfigBuffer::populate_from_config(const string& filename){

  std::string EntryValue;
  std::ifstream infile(filename.c_str());

  if ( infile == 0 ) {
    throw CBException("File \""+filename+"\" not found",__FILE__,__LINE__);
    return FAILURE; 
  } else {

  std::string key,value; 
  std::pair<string,string> KeyVal;  
  

  while (getline(infile,EntryValue)){

    if ( (EntryValue[0] != '#') &&  (EntryValue.find('=') != EntryValue.npos)) {


    key   =  EntryValue.substr(0,EntryValue.find ('='));
    value =  EntryValue.substr(EntryValue.find ('=')+1);
    
    key = key.erase (key.find_last_not_of (' ')+1);
    key = key.erase (0,key.find_first_not_of (' '));

    value = value.erase (value.find_last_not_of (' ')+1);
    value = value.erase (0,value.find_first_not_of (' '));
    
    KeyVal.first = key;
    KeyVal.second = value;  


    if ( _MBuffer.find(key) == _MBuffer.end()){

    _MBuffer.insert(KeyVal);
    
    } else {

      std::cout << "ATTRIBUTE \"" << key << "\" already exists ... skip entry" << std::endl;  
    }

    } else {
      // std::cout << "This is a comment !" << std::endl;
    }
  }
  
  return SUCCESS;
  }
}

void ConfigBuffer::show_map(){

  std::cout << " Map : ATTRIBUTE ==> VALUE " << std::endl;

  map<std::string,std::string>::const_iterator it_buffer = _MBuffer.begin();

  while (it_buffer != _MBuffer.end()){

    std::cout << it_buffer->first << " ==> " << it_buffer->second << std::endl;

    it_buffer++;

  }
}


std::vector<std::string> ConfigBuffer::list_attributes(){
   std::vector<std::string> aux;

   map<std::string,std::string>::const_iterator it_buffer = _MBuffer.begin();
   while (it_buffer != _MBuffer.end()){
      aux.push_back(it_buffer->first);
      it_buffer++;
   }
   return aux;
}
 

string ConfigBuffer::get_attribute_value (const string& Attribute){
   
  
  if ( _MBuffer.find(Attribute) != _MBuffer.end()){

   return _MBuffer[Attribute];
    
    } else {

      throw CBException("Attribute does not exist",__FILE__,__LINE__);
      return "";

    }
}   

REsult ConfigBuffer::set_attribute_value(const string& Attribute, const string& Value){

  if ( _MBuffer.find(Attribute) != _MBuffer.end()){

  _MBuffer[Attribute] = Value;
  return SUCCESS;
} else {
  
  throw CBException("Attribute does not exist",__FILE__,__LINE__);
  return FAILURE;

}

}

REsult ConfigBuffer::create_new_attribute(const string& Attribute){

if ( _MBuffer.find(Attribute) == _MBuffer.end()){
  
  std::pair<string,string> KeyVal(Attribute,"");
  _MBuffer.insert(KeyVal);  

  return SUCCESS;
} else {

  throw CBException("Attribute already exists",__FILE__,__LINE__);
  return FAILURE;
}


}


ConfigBuffer::~ConfigBuffer(){
//   std::cout << "ConfigBuffer ends ..." << std::endl;
}  



string CBException::DefMess = "+CB EXCEPTION: ";


CBException::CBException() {
 message=DefMess;
 filename="";
 linenumber=-1; 
}

CBException::CBException(const string& s, const string& file, const int& line){

 message=DefMess+s;
 filename=file;
 linenumber=line;
}

CBException::~CBException() {}

string CBException::what(){
  return message;
}

int CBException::get_line(){
  return linenumber;
}

string CBException::get_file(){
  return filename;
}

---