---

IFile.cxx

Go to the documentation of this file.

// $Header: /nfs/slac/g/glast/ground/cvs/xml/src/IFile.cxx,v 1.6 2001/03/13 22:02:36 tlindner Exp $
/*
 * User: Suson       Date: 6/29/98
 * Removed Rational Rose comments and restructured
 *   to use vectors
 */


#include "xml/IFile.h"
#include "xml/XmlParser.h"
#include "xml/Dom.h"
#include "facilities/error.h"
#include "dom/DOM_Document.hpp"

// #include <strstream>
#include <vector>


extern "C" {
  FILE *popen(const char *command, const char *type);
}


// implementation
#include <stdio.h>
#include <ctype.h>
#include <string.h>


// globals

namespace xml {

#define LEADING  1
#define ALL      2
#define TRAILING 4


  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::printOn (std::ostream& out) {
    for (iterator section_map=begin(); section_map!=end(); ++section_map) {
      IFile_Section& section = *(*section_map).second;
      out << "\n[" <<  (*section_map).first << "]\n";
      
      for( IFile_Section::iterator item_map = section.begin();
           item_map != section.end(); ++item_map){
        IFile_Item& item = *(*item_map).second;
        out << (*item_map).first << " = "  << (item.mystring()) << "\n";
      }
    }
  }
  
  void IFile::print(){printOn(std::cout); std::cout.flush();}

  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::stricmp (const char *str1, const char *str2)
    {
      while ( *str1  &&  *str2  &&  toupper(*str1)==toupper(*str2) )
      {
        str1++;
        str2++;
      }
      
      return (toupper(*str1) - toupper(*str2));
    }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::stripBlanks (char *str1, const char *str2, int flags)
    {
      if (flags & ALL)
      {
        while ( *str2 )
        {
          if (*str2==' '  ||  *str2=='\t')
            str2++;
          else
            *str1++ = *str2++;
        }
        *str1=0;
      }
      else
      {
        if (flags & LEADING)
          while ( *str2  &&  (*str2==' '  ||  *str2=='\t'))
            str2++;
        
        strcpy (str1, str2);
        
        if (flags & TRAILING)
        {
          str1 += strlen (str1);
          
          do str1--; while (*str1==' '  ||  *str1=='\t');
          *++str1 = 0;
        }
      }
    }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /*
    void IFile::stripBlanks2 (char *str1, const char *str2)
    {
    int flSkip=1;
    
    while ( *str2 )
    {
    if (flSkip)
    {
    if (*str2=='=')
    flSkip = 0;
    
    if (*str2==' '  ||  *str2=='\t')
    str2++;
    else
    *str1++ = *str2++;
    }
    else
    *str1++ = *str2++;
    }
    *str1=0;
    }
  */
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::extractEnvVar(std::string *fileStr) {
      //now pull out and substitute for environment vaiables
      // This routine, will modify the input string.
      int envStart = fileStr->find_first_of("$(");
      int envEnd = fileStr->find_first_of(")");
            
      // add 2 characters to get rid of $(
     int afterBracket = envStart + 2;
            
      if(!((envStart==-1)||(envEnd==-1)))
      {
          std::string envVariable = fileStr->substr(afterBracket,(envEnd-afterBracket));
          const char * path = ::getenv(envVariable.c_str());
          if(path) {
              fileStr->replace(envStart,(envEnd+1), path);
          }
      }
  }

  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::~IFile ()
    {
      iterator it = begin();
      while (it != end())
        delete (*it++).second;
      
    }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile_Section::~IFile_Section()
    {
      iterator it = begin();
      while (it != end())
        delete (*it++).second;
    }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  // IFile::IFile( std::istream & infile) : status(2)       ##Obsolete##
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::IFile (const DOM_Document& instrument)  
    {
      // check that argument is non-null
      if (instrument == DOM_Document()) {
        FATAL_MACRO("Attempt to construct IFile from null DOM_Document");
        return;
      }
      // If so, call service to do the actual work
      domToIni(instrument);
    }
  
  IFile::IFile (const DOM_Element& instrument)  
    {
      // check that argument is non-null
      if (instrument == DOM_Element()) {
        FATAL_MACRO("Attempt to construct IFile from null DOM_Element");
        return;
      }
      // If so, call service to do the actual work
      domToIni(instrument);
    }
  

  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::IFile (const char *filename) 
    {          
      XmlParser parser;
      
      std::string filenameStr = filename;
      extractEnvVar(&filenameStr);

      // What if this fails (e.g., file doesn't exist or is not 
      // well-formed)?? How to report it?
      DOM_Document doc = parser.parse(filenameStr.c_str());
      
      // Check it's a good doc.  
      if (doc == DOM_Document()) {
        FATAL_MACRO("Attempt to construct IFile from null DOM_Document");
        return;
      }
      
      // If so, initialize IFile from it
      domToIni(doc);
    }

  // Work of constructor minus parsing
  void IFile::domToIni(const DOM_Document& doc) {
    DOM_Element  root = doc.getDocumentElement();
    
    // Now invoke element version to do the work
    domToIni(root);
  }        

  void IFile::domToIni(const DOM_Element& root) {
    // Done this way, any child elements which are *not* sections
    // will simply be ignored.  Another strategy would be to look 
    // at all children and complain if any are not sections
    DOM_NodeList list = root.getElementsByTagName("section");
    
    DOM_Element   child;
    int           nChild = list.getLength();
    int           iChild;
    
    for (iChild = 0; iChild < nChild; iChild++) {
      DOM_Node node = list.item(iChild);
      // Only handle immediate children here
      if (node.getParentNode() == root) {
        child = DOM_Element(static_cast<DOM_Element &>(node));
        addSection(child);
      }
    }
  }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::addSection(const DOM_Element& section)  {
    if (!((section.getTagName()).equals("section"))) {
      FATAL_MACRO("Expecting tagName==section, found " << 
                Dom::transToChar(section.getTagName()) );
    }
    
    // start a section
    // DOM_Element::getAttribute returns a DOMString; hence need to transcode
    char*  sectName = Dom::transToChar((section.getAttribute("name")));
    IFile_Section* curSection = new IFile_Section(sectName);
    (*this)[curSection->title()]=curSection;
    
    DOM_NodeList list = section.getChildNodes();
    DOM_Element   child;
    int           nChild = list.getLength();
    int           iChild;
    
    for (iChild = 0; iChild < nChild; iChild++) {
      DOM_Node node = list.item(iChild);
      if (node.getNodeType() == DOM_Node::ELEMENT_NODE) {
        child = DOM_Element(static_cast<DOM_Element &>(node));
        
        if ((child.getTagName()).equals("section")) {
          addSection(child);
        }
        else if ((child.getTagName()).equals("item")) {
          // force a copy because Dom::transToChar uses a fixed buffer
          std::string  itemName(Dom::transToChar(child.getAttribute("name")));
          std::string itemValue(Dom::transToChar(child.getAttribute("value")));
          
          // Make the new item
          IFile_Item* newItem = 
            new IFile_Item(itemName, itemValue);
          // Add it to the section map
          (*curSection)[newItem->title()]= newItem;
        }
        else {
          char *tag = Dom::transToChar(child.getTagName());
          FATAL_MACRO("unexpected tag in initialization:" << tag);
        }
      }
    }
    
  }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  bool IFile::contains (const char *section, const char *item)
    {
      return (IFile::_getstring (section, item, 0) != 0);
    }
  
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  const char *IFile::_getstring(const char *sectionname, const char *itemname, 
                                int failFlag)
    {
      char     hitem[1000], hsection[1000];
      IFile_Item    *item = 0;
      IFile_Section *section =0;
      
      stripBlanks (hitem,    itemname,    ALL);
      stripBlanks (hsection, sectionname, ALL);
      
      const_iterator entry = find(std::string(hsection));
      
      if (entry  != end() )      {
        section = (*entry).second;
        
        IFile_Section::const_iterator it = section->find(std::string(hitem));
        item = (it != section->end() ) ?item = (*it).second :  0;
        
      }
      
      if (item != 0)   {
#ifdef DEBUG
        INFO ("getstring: [" << hsection << "]" << hitem << ": ->" << 
              (item->string()) << "<-");
#endif
        return item->mystring().c_str();
      }
      else if (failFlag)
      {
        if (section == 0)
          FATAL_MACRO ("cannot find section [" << sectionname << "]");
        else
          FATAL_MACRO ("cannot find item \"" << itemname << "\" in section [" << 
                       sectionname << "]");
        return 0;
      }
      
      else   return 0;
    }
  
  // getting data from [section]item, exiting when not found
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  const char *IFile::getString (const char *section, const char *item)
    {
      return _getstring(section, item);
    }
  
  // setting data in [section]
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::setString(const char *sectionname, const char *itemname, 
                        const char* newString)
    {
      char     hitem[1000], hsection[1000];
      IFile_Item    *item =0;
      IFile_Section *section=0;
      
      stripBlanks (hitem,    itemname,    ALL);
      stripBlanks (hsection, sectionname, ALL);
      
      iterator it = find(std::string(hsection));
      
      if ( it != end() )      {
        section = (*it).second;
        
        if (section->contains(hitem) )
          item = section->lookUp(hitem);
      }
      
      if (item) item->mystring()=newString;
    }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  double IFile::getDouble (const char *section, const char *item)
    {
      double    hf;
      std::string hilf (IFile::_getstring (section, item));
      
      if (sscanf(hilf.c_str(), "%le", &hf) != 1)
        FATAL_MACRO ("[" << section << "]" << item << " = \'" << hilf << 
                     "\' cannot be converted to double");
      
      return hf;
    }
  
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::getInt (const char *section, const char *item)
    {
      int       hf;
      std::string hilf (IFile::_getstring (section, item));
      
      if (sscanf(hilf.c_str(), "%d", &hf) != 1)
        FATAL_MACRO ("[" << section << "]" << item << " = \'" << hilf << 
                     "\' cannot be converted to int");
      
      return (hf);
    }
  
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::getBool (const char *section, const char *item)
    {
      std::string hilf (IFile::_getstring (section, item));
      
      if      (hilf == "yes")
        return (1);
      else if (hilf == "true")
        return (1);
      else if (hilf == "1")
        return (1);
      else if (hilf == "no")
        return (0);
      else if (hilf == "false")
        return (0);
      else if (hilf == "0")
        return (0);
      else
        FATAL_MACRO ("[" << section << "]" << item << " = \'" << hilf << 
                     "\' is not boolean");
      return (0);
    }
  
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::intVector IFile::getIntVector (const char *section, const char *item)
    {
      intVector iv;
      char buffer[1024];
      
      strncpy(buffer, IFile::_getstring(section,item), sizeof(buffer) -1);
      if ( strlen(buffer) >= sizeof(buffer) ) {
        FATAL_MACRO("string returned from _getstring is too long");
        return iv;
      }
      
      char *vString = strtok(buffer,"}");
      vString = strtok(buffer,"{");
      
      char *test = strtok(vString,",");
      while (test != NULL) {
        iv.push_back(atoi(test));
        test = strtok((char*)NULL,",");
      }
      if (iv.size() <= 0) {
        std::string hilf (buffer);
        FATAL_MACRO ("[" << section << "]"  << item << " = \'"
                     << hilf << "\' is not an integer vector");
      }
      return (iv);
    }
  
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::doubleVector IFile::getDoubleVector (const char *section, 
                                              const char *item)
    {
      doubleVector dv;
      char buffer[1024];
      
      strncpy(buffer, IFile::_getstring(section,item), sizeof(buffer) );
      if (strlen(buffer) >= sizeof(buffer) ) {
        FATAL_MACRO("string from _getstring() too long");
        return dv;
      }
      char *vString = strtok(buffer,"}");
      vString = strtok(buffer,"{");
      
      char *test = strtok(vString,",");
      while (test != NULL) {
        dv.push_back(atof(test));
        test = strtok((char*)NULL,",");
      }
      if (dv.size() <= 0) {
        std::string hilf (buffer);
        FATAL_MACRO ("[" << section << "]"  << item << " = \'"
                     << hilf << "\' is not an double vector");
      }
      return (dv);
    }
  
  // getting data from [section]item, with def. values provided
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::getInt (const char *section, const char *item, int defValue) {
    return ( contains(section, item) )? getInt( section, item ):defValue;
  }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::getBool (const char *section, const char *item, int defValue)
    {
      return ( contains(section, item) )? getBool( section, item ):defValue;
    }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  double IFile::getDouble(const char *section, const char *item, 
                          double defValue)   {
    return ( contains(section, item) )? getDouble( section, item ):defValue;
  }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  const char *IFile::getString (const char *section, const char *item, 
                                const char *defValue) {
    return ( contains(section, item) )? getString( section, item ):defValue;
  }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::intVector IFile::getIntVector (const char *section, const char *item, 
                                        intVector defValues)    {
    return (contains(section, item))? getIntVector(section, item) 
      : defValues;
  }
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::doubleVector IFile::getDoubleVector (const char *section, 
                                              const char *item, 
                                              doubleVector defValues)  {
    return (contains(section, item))? getDoubleVector(section, item):defValues;
  }
} //   end namespace xml

---