Parsers.h

Go to the documentation of this file.

// ============================================================================
#ifndef GAUDIPROPERTYPARSERS_PARSERS_H
#define GAUDIPROPERTYPARSERS_PARSERS_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>

// ============================================================================
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/HistoDef.h"

#define PARSERS_DECL_FOR_SINGLE(Type)\
    GAUDI_API StatusCode parse(Type& result, const std::string& input);

#define PARSERS_DECL_FOR_PAIR(FirstType, SecondType)\
    GAUDI_API StatusCode parse(std::pair<FirstType, SecondType >& result,\
                               const std::string& input);

#define PARSERS_DECL_FOR_LIST(InnerType)\
    GAUDI_API StatusCode parse(std::vector<InnerType>& result,\
                               const std::string& input);
// ============================================================================
// ============================================================================
namespace Gaudi
{
  // ==========================================================================
  class Histo1DDef ;
  // ==========================================================================
  namespace Parsers
  {
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(bool)
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(char)
    PARSERS_DECL_FOR_SINGLE(unsigned char)
    PARSERS_DECL_FOR_SINGLE(signed char)
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(int)
    PARSERS_DECL_FOR_SINGLE(short)
    PARSERS_DECL_FOR_SINGLE(unsigned short)
    PARSERS_DECL_FOR_SINGLE(unsigned int)
    PARSERS_DECL_FOR_SINGLE(long)
    PARSERS_DECL_FOR_SINGLE(unsigned long)
    PARSERS_DECL_FOR_SINGLE(long long)
    PARSERS_DECL_FOR_SINGLE(unsigned long long)
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(double)
    PARSERS_DECL_FOR_SINGLE(float)
    PARSERS_DECL_FOR_SINGLE(long double)
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(std::string)
    // ========================================================================

    PARSERS_DECL_FOR_LIST(bool)
    PARSERS_DECL_FOR_LIST(char)
    PARSERS_DECL_FOR_LIST(unsigned char)
    PARSERS_DECL_FOR_LIST(signed char)

    PARSERS_DECL_FOR_LIST(int)
    PARSERS_DECL_FOR_LIST(short)
    PARSERS_DECL_FOR_LIST(unsigned short)
    PARSERS_DECL_FOR_LIST(unsigned int)
    PARSERS_DECL_FOR_LIST(long)
    PARSERS_DECL_FOR_LIST(unsigned long)
    PARSERS_DECL_FOR_LIST(long long)
    PARSERS_DECL_FOR_LIST(unsigned long long)

    PARSERS_DECL_FOR_LIST(double)
    PARSERS_DECL_FOR_LIST(float)
    PARSERS_DECL_FOR_LIST(long double)

    PARSERS_DECL_FOR_LIST(std::string)
    // ========================================================================
    // Advanced parses
    // ========================================================================
    PARSERS_DECL_FOR_PAIR(double,double)
    // ========================================================================
    PARSERS_DECL_FOR_PAIR(int, int)
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::vector< std::pair<double,double> >& result ,
      const std::string&                       input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::vector< std::pair<int,int> >& result ,
      const std::string&                 input  ) ;
    // ========================================================================
    // vector< vector< TYPE > >
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::vector< std::vector<std::string> >& result ,
      const std::string&                       input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::vector< std::vector<double> >& result ,
      const std::string&                  input  ) ;
    // ========================================================================
    // map< TYPE, TYPE >
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< int , int >& result ,
      const std::string&     input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< int , double >& result ,
      const std::string&        input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , std::string >& result ,
      const std::string&                     input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , int >& result ,
      const std::string&             input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , double >& result ,
      const std::string&                input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , std::vector< std::string> >& result ,
      const std::string&                                   input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , std::vector< int > >& result ,
      const std::string&                            input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map< std::string , std::vector< double > >& result ,
      const std::string&                               input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map<int, std::string>& result ,
      const std::string&          input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map<unsigned int, std::string>& result ,
      const std::string&          input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map<std::string, unsigned int>& result ,
      const std::string&          input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::string&       name  ,
      std::string&       value ,
      const std::string& input ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( Gaudi::Histo1DDef& histo ,
      const std::string& input ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map<std::string,Gaudi::Histo1DDef>& histos ,
      const std::string&                       input  ) ;
    // ========================================================================
    GAUDI_API StatusCode parse
    ( std::map<std::string,std::pair<double,double> >& params ,
      const std::string&                               input  ) ;
    // ========================================================================
    template <class T, unsigned int N>
    StatusCode parse ( T(&result)[N] , const std::string& input )
    {
      typedef std::vector<T> _Vct ;
      // create the temporary vector
      _Vct tmp ;
      StatusCode sc = parse ( tmp , input ) ;
      if ( sc.isFailure()  ) { return sc                  ; }  //  RETURN
      if ( N != tmp.size() ) { return StatusCode::FAILURE ; }  //  RETURN
      //
      std::copy ( tmp.begin() , tmp.end() , result ) ;
      //
      return StatusCode::SUCCESS ;                            //  RETURN
    }
    // ========================================================================
    template <unsigned int N>
    StatusCode parse ( char(&result)[N] , const std::string& input )
    {
      // clear the string
      std::fill_n ( result , N , ' ' ) ;
      // create the temporary string
      std::string tmp ;
      StatusCode sc = parse ( tmp , input ) ;
      if ( sc.isFailure()  ) { return sc                 ; }  //  RETURN
      if       ( N     == tmp.size() )
      { std::copy ( tmp.begin() , tmp.end() , result ) ; }
      else if  ( N + 2    == tmp.size()                 &&
                 ( '\''   == tmp[0] || '\"' == tmp[0] ) &&
                 ( tmp[0] == tmp[tmp.size()-1]          ))
      { std::copy ( tmp.begin() + 1 , tmp.end() -1 , result ) ; }
      else { return StatusCode::FAILURE ; }
      //
      return StatusCode::SUCCESS ;                            //  RETURN
    }
    // ========================================================================
  } //                                          end of namespace Gaudi::Parsers
  // ==========================================================================
} //                                                     end of namespace Gaudi
// ============================================================================
// The END
// ============================================================================
#endif //GAUDIPROPERTYPARSERS_PARSERS_H
// ============================================================================