ParsersVct.cpp

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2019 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.                                             *
\***********************************************************************************/
// ============================================================================
// Include files
// ============================================================================
#include "GaudiKernel/VectorsAsProperty.h"
// ============================================================================
#include "GaudiKernel/ToStream.h"
#include <Gaudi/Parsers/Factory.h>
// ============================================================================
namespace {
  // ==========================================================================
  typedef std::map<std::string, double> MAP;

  template <unsigned int N>
  inline MAP::const_iterator find( const MAP& m, const std::string ( &keys )[N] ) {
    for ( unsigned int i = 0; i < N; ++i ) {
      auto found = m.find( keys[i] );
      if ( m.end() != found ) { return found; }
    }
    return m.end();
  }
  // ==========================================================================
  const std::string s_X[] = {"x", "X", "px", "pX", "Px", "PX"};
  const std::string s_Y[] = {"y", "Y", "py", "pY", "Py", "PY"};
  const std::string s_Z[] = {"z", "Z", "pz", "pZ", "Pz", "PZ"};
  const std::string s_E[] = {"t", "T", "e", "E"};
  // ==========================================================================
} // namespace
// ============================================================================
namespace Gaudi {
  namespace Parsers {
    template <typename T1, typename T2>
    inline StatusCode parse_( ROOT::Math::PositionVector3D<T1, T2>& result, const std::string& input ) {
      Skipper                                                                              skipper;
      typename Grammar_<IteratorT, ROOT::Math::PositionVector3D<T1, T2>, Skipper>::Grammar g;
      IteratorT iter = input.begin(), end = input.end();
      if ( qi::phrase_parse( iter, end, g, skipper, result ) ) { return StatusCode::SUCCESS; }
      //@attention always
      return StatusCode::SUCCESS;
    }
    // ==========================================================================

    StatusCode parse( Gaudi::XYZPoint& result, const std::string& input ) { return parse_( result, input ); }

    // ==========================================================================
    /*  parse 3D-vector
     *  @param result (output) the parsed vector
     *  @param input  (input)  the input string
     *  @return status code
     *  @author Vanya BELYAEV Ivan.Belyaev@nikhef.nl
     *  @date 2009-09-05
     */
    StatusCode parse( Gaudi::XYZVector& result, const std::string& input ) {

      Gaudi::XYZPoint point;
      StatusCode      sc = parse( point, input );
      if ( sc.isFailure() ) { return sc; } // RETURN
      result = point;
      return StatusCode::SUCCESS; // RETURN
    }

    StatusCode parse( Gaudi::LorentzVector& result, const std::string& input ) { return parse_( result, input ); }

    // ==========================================================================
    /*  parse the vector of points
     *  @param resut (OUTPUT) the parser vector
     *  @param input (INPIUT) the string to be parsed
     *  @author Vanya BELYAEV Ivan.Belyaev@nikhef.nl
     *  @date 2009-09-05
     */
    // ==========================================================================
    StatusCode parse( std::vector<Gaudi::XYZPoint>& result, const std::string& input ) {
      result.clear();
      return parse_( result, input );
    }
    // ==========================================================================
    /*  parse the vector of vectors
     *  @param resut (OUTPUT) the parser vector
     *  @param input (INPIUT) the string to be parsed
     *  @author Vanya BELYAEV Ivan.Belyaev@nikhef.nl
     *  @date 2009-09-05
     */
    // ==========================================================================
    StatusCode parse( std::vector<Gaudi::XYZVector>& result, const std::string& input ) {
      result.clear();
      return parse_( result, input );
    }

#ifndef _WIN32
    // ==========================================================================
    /*  parse the vector of vectors
     *  @param resut (OUTPUT) the parser vector
     *  @param input (INPIUT) the string to be parsed
     *  @author Vanya BELYAEV Ivan.Belyaev@nikhef.nl
     *  @date 2009-09-05
     */
    // ==========================================================================
    StatusCode parse( std::vector<Gaudi::LorentzVector>& result, const std::string& input ) {
      return parse_( result, input );
    }
#endif
  } // namespace Parsers
} // namespace Gaudi
// ============================================================================
// print XYZ-point
// ============================================================================
std::ostream& Gaudi::Utils::toStream( const Gaudi::XYZPoint& obj, std::ostream& s ) {
  s << "( ";
  toStream( obj.X(), s );
  s << " , ";
  toStream( obj.Y(), s );
  s << " , ";
  toStream( obj.Z(), s );
  s << " )";
  return s;
}
// ============================================================================
// print XYZ-vector
// ============================================================================
std::ostream& Gaudi::Utils::toStream( const Gaudi::XYZVector& obj, std::ostream& s ) {
  s << "( ";
  toStream( obj.X(), s );
  s << " , ";
  toStream( obj.Y(), s );
  s << " , ";
  toStream( obj.Z(), s );
  s << " )";

  return s;
}
// ============================================================================
// print LorentzVector
// ============================================================================
std::ostream& Gaudi::Utils::toStream( const Gaudi::LorentzVector& obj, std::ostream& s ) {

  s << "( ";
  toStream( obj.Px(), s, 12 );
  s << " , ";
  toStream( obj.Py(), s, 12 );
  s << " , ";
  toStream( obj.Pz(), s, 13 );
  s << " , ";
  toStream( obj.E(), s, 14 );
  s << " )";

  return s;
}
// ============================================================================