CommonParsers.h

Go to the documentation of this file.

#pragma once
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>

// ============================================================================
#include "GaudiKernel/HistoDef.h"
#include "GaudiKernel/Map.h"
#include "GaudiKernel/StatusCode.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 );
    // ========================================================================
    template <typename K, typename V, typename M>
    GAUDI_API StatusCode parse( GaudiUtils::Map<K, V, M>& result, const std::string& input )
    {
      return parse( (M&)result, 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