CommonParsers.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/HistoDef.h>
#include <GaudiKernel/Map.h>
#include <GaudiKernel/StatusCode.h>
#include <list>
#include <map>
#include <nlohmann/json_fwd.hpp>
#include <set>
#include <string>
#include <unordered_set>
#include <vector>
 
#define PARSERS_DECL_FOR_SINGLE( Type ) GAUDI_API StatusCode parse( Type& result, std::string_view input );
 
#define PARSERS_DECL_FOR_PAIR( FirstType, SecondType )                                                                 \
  GAUDI_API StatusCode parse( std::pair<FirstType, SecondType>& result, std::string_view input );
 
#define PARSERS_DECL_FOR_LIST( InnerType )                                                                             \
  GAUDI_API StatusCode parse( std::vector<InnerType>& result, std::string_view input );
 
#define PARSERS_DECL_FOR_SET( InnerType )                                                                              \
  GAUDI_API StatusCode parse( std::set<InnerType>& result, std::string_view input );                                   \
  GAUDI_API StatusCode parse( std::unordered_set<InnerType>& result, std::string_view input );
 
#define PARSERS_DECL_FOR_STRMAP( ValueType )                                                                           \
  GAUDI_API StatusCode parse( std::map<std::string, ValueType>& result, std::string_view input );                      \
  GAUDI_API StatusCode parse( std::map<std::string, ValueType, std::less<>>& result, std::string_view 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_SINGLE( nlohmann::json )
 
    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 )
 
    PARSERS_DECL_FOR_SET( bool )
    PARSERS_DECL_FOR_SET( char )
    PARSERS_DECL_FOR_SET( unsigned char )
    PARSERS_DECL_FOR_SET( signed char )
 
    PARSERS_DECL_FOR_SET( int )
    PARSERS_DECL_FOR_SET( short )
    PARSERS_DECL_FOR_SET( unsigned short )
    PARSERS_DECL_FOR_SET( unsigned int )
    PARSERS_DECL_FOR_SET( long )
    PARSERS_DECL_FOR_SET( unsigned long )
    PARSERS_DECL_FOR_SET( long long )
    PARSERS_DECL_FOR_SET( unsigned long long )
 
    PARSERS_DECL_FOR_SET( double )
    PARSERS_DECL_FOR_SET( float )
    PARSERS_DECL_FOR_SET( long double )
 
    PARSERS_DECL_FOR_SET( std::string )
 
    // Parsers for std::map<std::string, T>
    PARSERS_DECL_FOR_STRMAP( std::string )
    PARSERS_DECL_FOR_STRMAP( int )
    PARSERS_DECL_FOR_STRMAP( unsigned int )
    PARSERS_DECL_FOR_STRMAP( double )
    PARSERS_DECL_FOR_STRMAP( std::vector<std::string> )
    PARSERS_DECL_FOR_STRMAP( std::vector<int> )
    PARSERS_DECL_FOR_STRMAP( std::vector<double> )
    using IntPair    = std::pair<int, int>; // needed to avoid macro parsing error due to brackets
    using DoublePair = std::pair<double, double>;
    PARSERS_DECL_FOR_STRMAP( IntPair )
    PARSERS_DECL_FOR_STRMAP( DoublePair )
    PARSERS_DECL_FOR_STRMAP( Gaudi::Histo1DDef )

    PARSERS_DECL_FOR_PAIR( double, double )
    PARSERS_DECL_FOR_PAIR( int, int )
    GAUDI_API StatusCode parse( std::vector<std::pair<double, double>>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::vector<std::pair<int, int>>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::vector<std::vector<std::string>>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::vector<std::vector<double>>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::vector<std::vector<float>>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::vector<std::vector<int>>& result, std::string_view input );
    // map< TYPE, TYPE >
    GAUDI_API StatusCode parse( std::map<int, int>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::map<int, double>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::map<int, std::string>& result, std::string_view input );
    GAUDI_API StatusCode parse( std::map<unsigned int, std::string>& result, std::string_view input );
    template <typename K, typename V, typename M>
    GAUDI_API StatusCode parse( GaudiUtils::Map<K, V, M>& result, std::string_view input ) {
      return parse( static_cast<M&>( result ), input );
    }

    GAUDI_API StatusCode parse( std::string& name, std::string& value, std::string_view input );
    GAUDI_API StatusCode parse( Gaudi::Histo1DDef& histo, std::string_view input );
    template <class T, unsigned int N>
    StatusCode parse( T ( &result )[N], std::string_view input ) {
      typedef std::vector<T> _Vct;
      // create the temporary vector
      _Vct       tmp;
      StatusCode sc = parse( tmp, input );
      if ( sc.isFailure() ) { return sc; }
      if ( N != tmp.size() ) { return StatusCode::FAILURE; }
      //
      std::copy( tmp.begin(), tmp.end(), result );
      //
      return StatusCode::SUCCESS;
    }

    template <unsigned int N>
    StatusCode parse( char ( &result )[N], std::string_view 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; }
      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;
    }
  } // namespace Parsers
} // namespace Gaudi