IFile.cxx

Go to the documentation of this file.

// $Header: /bes/bes/BossCvs/Calibration/xmlBase/src/IFile.cxx,v 1.1.1.1 2005/10/17 06:10:27
// maqm Exp $
 
#include "xmlBase/IFile.h"
#include "facilities/Util.h" // for expandEnvVar
#include "xmlBase/Dom.h"
#include "xmlBase/XmlParser.h"
#include <xercesc/dom/DOMDocument.hpp>
 
#include <cctype>
#include <cstdio>
#include <sstream>
#include <string>
#include <vector>
 
#define FATAL_MACRO( output )                                                                 \
  std::cerr << output;                                                                        \
  throw( IFileException( output ) )
 
// globals
 
namespace xmlBase {
 
  XERCES_CPP_NAMESPACE_USE
 
#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;
      }
    }
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  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( const DOMDocument* doc ) {
    // check that argument is non-null
    if ( doc == 0 )
    {
      //  FATAL_MACRO("Attempt to construct IFile from null DOMDocument");
      std::cerr << "Attempt to construct IFile from null DOMDocument" << std::endl;
      std::cerr.flush();
      exit( 1 );
    }
    // If so, call service to do the actual work
    domToIni( doc );
  }
 
  IFile::IFile( const DOMElement* doc ) {
    // check that argument is non-null
    if ( doc == 0 )
    {
      //        FATAL_MACRO("Attempt to construct IFile from null DOMElement");
      std::cerr << "Attempt to construct IFile from null DOMDocument" << std::endl;
      std::cerr.flush();
      exit( 1 );
    }
    // If so, call service to do the actual work
    domToIni( doc );
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  IFile::IFile( const char* filename ) {
    using facilities::Util;
 
    XmlParser parser;
 
    parser.doSchema( true );
 
    std::string filenameStr = filename;
    Util::expandEnvVar( &filenameStr );
 
    // What if this fails (e.g., file doesn't exist or is not
    // well-formed)?? How to report it?
    DOMDocument* doc = parser.parse( filenameStr.c_str() );
 
    // Check it's a good doc.
    if ( doc == 0 )
    {
      std::cerr << "Attempt to construct IFile from null DOMDocument" << std::endl;
      std::cerr.flush();
      exit( 1 );
      //   FATAL_MACRO("Attempt to construct IFile from null DomDocument");
    }
 
    // If so, initialize IFile from it
    domToIni( doc );
  }
 
  // Work of constructor minus parsing
  void IFile::domToIni( const DOMDocument* doc ) {
    DOMElement* root = doc->getDocumentElement();
 
    // Now invoke element version to do the work
    domToIni( root );
  }
 
  void IFile::domToIni( const DOMElement* 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
    std::vector<DOMElement*> sections;
    Dom::getChildrenByTagName( root, "section", sections );
    unsigned int nChild = sections.size();
 
    for ( unsigned int iChild = 0; iChild < nChild; iChild++ )
    { addSection( sections[iChild] ); }
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  void IFile::addSection( const DOMElement* section ) {
    std::string tagName = Dom::getTagName( section );
 
    if ( tagName.compare( "section" ) )
    {
      std::string errorString = "Expecting tagName==section, found " + tagName;
      FATAL_MACRO( errorString );
    }
 
    // start a section
    std::string    sectName        = Dom::getAttribute( section, "name" );
    IFile_Section* curSection      = new IFile_Section( sectName );
    ( *this )[curSection->title()] = curSection;
 
    std::vector<DOMElement*> children;
 
    Dom::getChildrenByTagName( section, "*", children );
 
    unsigned int nChild = children.size();
    for ( unsigned int iChild = 0; iChild < nChild; iChild++ )
    {
      DOMElement* child   = children[iChild];
      std::string tagName = Dom::getTagName( child );
      if ( !( tagName.compare( "section" ) ) ) { addSection( child ); }
      else if ( !( tagName.compare( "item" ) ) )
      {
        std::string itemName  = Dom::getAttribute( child, "name" );
        std::string itemValue = Dom::getAttribute( child, "value" );
 
        // Make the new item
        IFile_Item* newItem = new IFile_Item( itemName, itemValue );
        // Add it to the section map
        ( *curSection )[newItem->title()] = newItem;
      }
      else
      {
        std::string errorString = "unexpected tag in initialization:" + tagName;
        FATAL_MACRO( errorString );
      } // end if..else
    }   // end for
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  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 )
      {
        std::string errorString = std::string( "cannot find section [" ) + sectionname + "]";
        FATAL_MACRO( errorString );
      }
      else
      {
        std::string errorString = std::string( "cannot find item '" ) + itemname +
                                  "' in section [" + sectionname + "]";
        FATAL_MACRO( errorString );
      }
      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 ) );
 
    try
    { return facilities::Util::stringToDouble( hilf ); } catch ( facilities::WrongType ex )
    {
      std::cerr << ( "from xmlBase::IFile::getDouble  " ) << std::endl;
      //        FATAL_MACRO
      std::cerr << ex.getMsg() << std::endl;
      throw( IFileException( " " ) );
    }
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  int IFile::getInt( const char* section, const char* item ) {
    //      int       hf;
    std::string hilf( IFile::_getstring( section, item ) );
 
    try
    { return facilities::Util::stringToInt( hilf ); } catch ( facilities::WrongType ex )
    {
      std::cerr << ( "from xmlBase::IFile::getInt  " ) << std::endl;
      std::cerr << ex.getMsg() << std::endl;
      throw( IFileException( " " ) );
    }
  }
 
  //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  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
    {
      std::string errorString( "[" );
      errorString +=
          section + std::string( "]" ) + item + " = \'" + hilf + "\' is not boolean";
      FATAL_MACRO( errorString );
      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 );
      std::string errorString( "[" );
      errorString +=
          section + std::string( "]" ) + item + " = \'" + hilf + "\' is not an integer vector";
      FATAL_MACRO( errorString );
    }
    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 );
      std::string errorString( "[" );
      errorString +=
          section + std::string( "]" ) + item + " = \'" + hilf + "\' is not an double vector";
      FATAL_MACRO( errorString );
    }
    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 xmlBase