Parsers.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DD4HEP_PARSERS_H
#define DD4HEP_PARSERS_H 1
// ============================================================================
// Include files
// ============================================================================
// STD & STL
// ============================================================================
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <deque>

// ============================================================================
#define PARSERS_DECL_FOR_SINGLE(Type)                 \
  int parse(Type& result, const std::string& input);

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

#if defined(DD4HEP_HAVE_ALL_PARSERS)
#define PARSERS_DECL_FOR_LIST(InnerType)                                \
  int parse(std::vector<InnerType >& result,const std::string& input);  \
  int parse(std::list<InnerType >& result,const std::string& input);    \
  int parse(std::set<InnerType >& result,const std::string& input);     \
  int parse(std::deque<InnerType >& result,const std::string& input);   \
  int parse(std::map<std::string,InnerType >& result,const std::string& input); \
  int parse(std::map<int,InnerType >& result,const std::string& input); \
  int parse(std::map<unsigned long,InnerType >& result,const std::string& input); \
  int parse(std::pair<std::string,InnerType >& result,const std::string& input); \
  int parse(std::pair<int,InnerType >& result,const std::string& input); \
  int parse(std::pair<unsigned long,InnerType >& result,const std::string& input);

#else

#define PARSERS_DECL_FOR_LIST(InnerType)                                 \
  int parse(std::vector<InnerType >& result,const std::string& input);   \
  int parse(std::list<InnerType >& result,const std::string& input);     \
  int parse(std::set<InnerType >& result,const std::string& input);      \
  int parse(std::map<std::string,InnerType >& result,const std::string& input); \
  int parse(std::map<int,InnerType >& result,const std::string& input);  \
  int parse(std::pair<std::string,InnerType >& result,const std::string& input); \
  int parse(std::pair<int,InnerType >& result,const std::string& input);

#endif   //  DD4HEP_HAVE_ALL_PARSERS

// ============================================================================
// ============================================================================

namespace DD4hep {
  namespace Parsers {

    // ========================================================================

    PARSERS_DECL_FOR_SINGLE(bool)
    // ========================================================================

#if defined(DD4HEP_HAVE_ALL_PARSERS)
    PARSERS_DECL_FOR_SINGLE(char)
    PARSERS_DECL_FOR_SINGLE(unsigned char)
    PARSERS_DECL_FOR_SINGLE(signed char)
#endif
    // ========================================================================

    PARSERS_DECL_FOR_SINGLE(int)
    PARSERS_DECL_FOR_SINGLE(long)
#if defined(DD4HEP_HAVE_ALL_PARSERS)
    PARSERS_DECL_FOR_SINGLE(short)
    PARSERS_DECL_FOR_SINGLE(unsigned short)
    PARSERS_DECL_FOR_SINGLE(unsigned int)
    PARSERS_DECL_FOR_SINGLE(unsigned long)
    PARSERS_DECL_FOR_SINGLE(long long)
    PARSERS_DECL_FOR_SINGLE(unsigned long long)
#endif
    // ========================================================================

    PARSERS_DECL_FOR_SINGLE(double)
    PARSERS_DECL_FOR_SINGLE(float)
#if defined(DD4HEP_HAVE_ALL_PARSERS)
    PARSERS_DECL_FOR_SINGLE(long double)
#endif
    // ========================================================================
    PARSERS_DECL_FOR_SINGLE(std::string)
    // ========================================================================

    PARSERS_DECL_FOR_LIST(int)
    PARSERS_DECL_FOR_LIST(long)
    PARSERS_DECL_FOR_LIST(bool)
    PARSERS_DECL_FOR_LIST(double)
    PARSERS_DECL_FOR_LIST(float)
    PARSERS_DECL_FOR_LIST(std::string)

#if defined(DD4HEP_HAVE_ALL_PARSERS)
    PARSERS_DECL_FOR_LIST(char)
    PARSERS_DECL_FOR_LIST(unsigned char)
    PARSERS_DECL_FOR_LIST(signed char)
    PARSERS_DECL_FOR_LIST(short)
    PARSERS_DECL_FOR_LIST(unsigned short)
    PARSERS_DECL_FOR_LIST(unsigned int)
    PARSERS_DECL_FOR_LIST(unsigned long)
    PARSERS_DECL_FOR_LIST(long long)
    PARSERS_DECL_FOR_LIST(unsigned long long)
    PARSERS_DECL_FOR_LIST(long double)
#endif

    // ========================================================================
    // Advanced parses
    // ========================================================================

    PARSERS_DECL_FOR_PAIR(double, double)
    // ========================================================================
    PARSERS_DECL_FOR_PAIR(int, int)
    // ========================================================================

    

    int parse(std::vector<std::pair<double, double> >& result, const std::string& input);
    // ========================================================================

    int parse(std::vector<std::pair<int, int> >& result, const std::string& input);
    // ========================================================================
    // vector< vector< TYPE > >
    // ========================================================================

    int parse(std::vector<std::vector<std::string> >& result, const std::string& input);
    // ========================================================================

    int parse(std::vector<std::vector<double> >& result, const std::string& input);
    // ========================================================================
    // map< TYPE, TYPE >
    // ========================================================================

    int parse(std::map<int, int>& result, const std::string& input);
    // ========================================================================

    int parse(std::map<int, double>& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, std::string>& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, int>& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, double>& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, std::vector<std::string> >& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, std::vector<int> >& result, const std::string& input);
    // ========================================================================

    int parse(std::map<std::string, std::vector<double> >& result, const std::string& input);
    // ========================================================================

    int parse(std::map<int, std::string>& result, const std::string& input);

    // ========================================================================

#if defined(DD4HEP_HAVE_ALL_PARSERS)
    int parse(std::map<unsigned int, std::string>& result, const std::string& input);

    // ========================================================================

    int parse(std::map<std::string, unsigned int>& result, const std::string& input);
#endif

    // ========================================================================

    int parse(std::string& name, std::string& value, const std::string& input);

    // ========================================================================

    int parse(std::map<std::string, std::pair<double, double> >& params, const std::string& input);

    // ========================================================================

    template <class T, unsigned int N>
    int parse(T (&result)[N], const std::string& input) {
      typedef std::vector<T> _Vct;
      // create the temporary vector
      _Vct tmp;
      int sc = parse(tmp, input);
      if (!sc) {
        return sc;
      }   //  RETURN
      if (N != tmp.size()) {
        return 0;
      }   //  RETURN
      //
      std::copy(tmp.begin(), tmp.end(), result);
      //
      return 1;                            //  RETURN
    }
    // ========================================================================

    template <unsigned int N>
    int parse(char (&result)[N], const std::string& input) {
      // clear the string
      std::fill_n(result, N, ' ');
      // create the temporary string
      std::string tmp;
      int sc = parse(tmp, input);
      if (!sc) {
        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 0;
      }
      //
      return 1;                            //  RETURN
    }
    // ========================================================================
  }//                                          end of namespace Parsers
  // ==========================================================================
}//                                            end of namespace DD4hep

#ifndef DD4HEP_PARSERS_NO_ROOT

#include "Math/Point3D.h"
#include "Math/Vector3D.h"
#include "Math/Vector4D.h"

namespace ROOT {
  namespace Math {
    bool operator<(const XYZPoint& a, const XYZPoint& b);
    bool operator<(const XYZVector& a, const XYZVector& b);
    bool operator<(const PxPyPzEVector& a, const PxPyPzEVector& b);
  }
}

namespace DD4hep {
  namespace Parsers {

    // ========================================================================

    int parse(ROOT::Math::XYZPoint& result, const std::string& input);

    // ========================================================================

    int parse( ROOT::Math::XYZVector& result, const std::string& input);

    // ========================================================================

    int parse(ROOT::Math::PxPyPzEVector& result, const std::string& input);

    // ========================================================================

    PARSERS_DECL_FOR_LIST(ROOT::Math::XYZPoint)

    // ========================================================================

    PARSERS_DECL_FOR_LIST(ROOT::Math::XYZVector)

    // ========================================================================

    PARSERS_DECL_FOR_LIST(ROOT::Math::PxPyPzEVector)
    // ========================================================================
  }//                                          end of namespace Parsers
  // ==========================================================================
}//                                            end of namespace DD4hep
#endif
// ============================================================================
// The END
// ============================================================================
#endif // DD4HEP_PARSERS_H
// ============================================================================