#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/JobOptionsSvc/PropertyValue.h>

Collaboration diagram for Gaudi::Parsers::PropertyValue:

[legend]

Public Types
using	VectorOfStrings = std::vector< std::string >

using	MapOfStrings = std::map< std::string, std::string, std::less<> >

using	Value = std::variant< std::string, VectorOfStrings, MapOfStrings >

Public Member Functions
	PropertyValue (Value value, bool is_reference=false)

	PropertyValue (Value value, const Position &position, bool is_reference=false)

const Position &	position () const

std::string &	String ()

const std::string &	String () const

VectorOfStrings &	Vector ()

const VectorOfStrings &	Vector () const

MapOfStrings &	Map ()

const MapOfStrings &	Map () const

std::string	ToString () const

bool	HasPosition () const

bool	IsSimple () const

bool	IsVector () const

bool	IsMap () const

bool	IsReference () const

PropertyValue &	operator+= (const PropertyValue &right)

const PropertyValue	operator+ (const PropertyValue &right)

PropertyValue &	operator-= (const PropertyValue &right)

const PropertyValue	operator- (const PropertyValue &right)

Private Attributes
Value	value_

Position	position_

bool	is_reference_

Detailed Description

Definition at line 22 of file PropertyValue.h.

Member Typedef Documentation

◆ MapOfStrings

using Gaudi::Parsers::PropertyValue::MapOfStrings = std::map<std::string, std::string, std::less<> >

Definition at line 25 of file PropertyValue.h.

◆ Value

using Gaudi::Parsers::PropertyValue::Value = std::variant<std::string, VectorOfStrings, MapOfStrings>

Definition at line 26 of file PropertyValue.h.

◆ VectorOfStrings

using Gaudi::Parsers::PropertyValue::VectorOfStrings = std::vector<std::string>

Definition at line 24 of file PropertyValue.h.

Constructor & Destructor Documentation

◆ PropertyValue() [1/2]

Gaudi::Parsers::PropertyValue::PropertyValue	(	Value	value,
		bool	is_reference = `false`
	)

inlineexplicit

Definition at line 29 of file PropertyValue.h.

30 : value_( std::move( value ) ), is_reference_( is_reference ) {}

◆ PropertyValue() [2/2]

Gaudi::Parsers::PropertyValue::PropertyValue	(	Value	value,
		const Position &	position,
		bool	is_reference = `false`
	)

inline

Definition at line 31 of file PropertyValue.h.

32 : value_( std::move( value ) ), position_( position ), is_reference_( is_reference ) {}

Member Function Documentation

◆ HasPosition()

bool Gaudi::Parsers::PropertyValue::HasPosition ( ) const

inline

Definition at line 46 of file PropertyValue.h.

46 { return position_.Exists(); }

◆ IsMap()

bool Gaudi::Parsers::PropertyValue::IsMap ( ) const

Definition at line 20 of file PropertyValue.cpp.

20 { return std::holds_alternative<MapOfStrings>( value_ ); }

◆ IsReference()

bool Gaudi::Parsers::PropertyValue::IsReference ( ) const

inline

Definition at line 50 of file PropertyValue.h.

50 { return is_reference_; };

◆ IsSimple()

bool Gaudi::Parsers::PropertyValue::IsSimple ( ) const

Definition at line 18 of file PropertyValue.cpp.

18 { return std::holds_alternative<std::string>( value_ ); }

◆ IsVector()

bool Gaudi::Parsers::PropertyValue::IsVector ( ) const

Definition at line 19 of file PropertyValue.cpp.

19 { return std::holds_alternative<VectorOfStrings>( value_ ); }

◆ Map() [1/2]

MapOfStrings& Gaudi::Parsers::PropertyValue::Map ( )

inline

Definition at line 42 of file PropertyValue.h.

42 { return std::get<MapOfStrings>( value_ ); }

◆ Map() [2/2]

const MapOfStrings& Gaudi::Parsers::PropertyValue::Map ( ) const

inline

Definition at line 43 of file PropertyValue.h.

43 { return std::get<MapOfStrings>( value_ ); }

◆ operator+()

const gp::PropertyValue Gaudi::Parsers::PropertyValue::operator+ ( const PropertyValue & right )

Definition at line 35 of file PropertyValue.cpp.

                                                                              {
   return PropertyValue{ *this } += right;
 }

◆ operator+=()

gp::PropertyValue & Gaudi::Parsers::PropertyValue::operator+= ( const PropertyValue & right )

Definition at line 21 of file PropertyValue.cpp.

                                                                          {
  
   if ( IsReference() ) { throw PropertyValueException::WrongLValue(); }
   std::visit(
       Gaudi::overload(
           []( std::string&, const auto& ) { throw PropertyValueException::WrongLValue(); },
           []( VectorOfStrings& lhs, const std::string& rhs ) { lhs.push_back( rhs ); },
           []( VectorOfStrings& lhs, const VectorOfStrings& rhs ) { lhs.insert( lhs.end(), rhs.begin(), rhs.end() ); },
           []( MapOfStrings& lhs, const MapOfStrings& rhs ) { lhs.insert( rhs.begin(), rhs.end() ); },
           []( auto&, const auto& ) { throw PropertyValueException::WrongRValue(); } ),
       value_, right.value_ );
   return *this;
 }

◆ operator-()

const gp::PropertyValue Gaudi::Parsers::PropertyValue::operator- ( const PropertyValue & right )

Definition at line 57 of file PropertyValue.cpp.

                                                                              {
   return PropertyValue{ *this } -= right;
 }

◆ operator-=()

gp::PropertyValue & Gaudi::Parsers::PropertyValue::operator-= ( const PropertyValue & right )

Definition at line 39 of file PropertyValue.cpp.

                                                                          {
   if ( IsReference() ) { throw PropertyValueException::WrongLValue(); }
   std::visit(
       Gaudi::overload( []( std::vector<std::string>& lhs,
                            const std::string&        rhs ) { lhs.erase( std::find( lhs.begin(), lhs.end(), rhs ) ); },
                        []( std::vector<std::string>& lhs, const std::vector<std::string>& rhs ) {
                          for ( const auto& item : rhs ) lhs.erase( std::find( lhs.begin(), lhs.end(), item ) );
                        },
                        []( std::map<std::string, std::string>& lhs, const std::string& rhs ) { lhs.erase( rhs ); },
                        []( std::map<std::string, std::string>& lhs, const std::vector<std::string>& rhs ) {
                          for ( const auto& item : rhs ) lhs.erase( item );
                        },
                        []( std::string&, const auto& ) { throw PropertyValueException::WrongLValue(); },
                        []( auto&, const auto& ) { throw PropertyValueException::WrongRValue(); } ),
       value_, right.value_ );
   return *this;
 }

◆ position()

const Position& Gaudi::Parsers::PropertyValue::position ( ) const

inline

Definition at line 34 of file PropertyValue.h.

34 { return position_; }

◆ String() [1/2]

std::string& Gaudi::Parsers::PropertyValue::String ( )

inline

Definition at line 36 of file PropertyValue.h.

36 { return std::get<std::string>( value_ ); }

◆ String() [2/2]

const std::string& Gaudi::Parsers::PropertyValue::String ( ) const

inline

Definition at line 37 of file PropertyValue.h.

37 { return std::get<std::string>( value_ ); }

◆ ToString()

std::string Gaudi::Parsers::PropertyValue::ToString ( ) const

Definition at line 61 of file PropertyValue.cpp.

                                           {
   if ( IsReference() ) {
     const auto& value = std::get<VectorOfStrings>( value_ );
     if ( value.at( 0 ) != "" ) {
       return "@" + value.at( 0 ) + "." + value.at( 1 );
     } else {
       return "@" + value.at( 0 );
     }
   }
   return std::visit(
       Gaudi::overload( []( const std::string& v ) { return v; },
                        []( const VectorOfStrings& v ) { return '[' + boost::algorithm::join( v, ", " ) + ']'; },
                        []( const MapOfStrings& v ) {
                          std::string result = "{";
                          std::string delim  = "";
                          for ( const auto& in : v ) {
                            result += delim + in.first + ":" + in.second;
                            delim = ", ";
                          }
                          return result + "}";
                        } ),
       value_ );
 }

◆ Vector() [1/2]

VectorOfStrings& Gaudi::Parsers::PropertyValue::Vector ( )

inline

Definition at line 39 of file PropertyValue.h.

39 { return std::get<VectorOfStrings>( value_ ); }

◆ Vector() [2/2]

const VectorOfStrings& Gaudi::Parsers::PropertyValue::Vector ( ) const

inline

Definition at line 40 of file PropertyValue.h.

40 { return std::get<VectorOfStrings>( value_ ); }

Member Data Documentation

◆ is_reference_

bool Gaudi::Parsers::PropertyValue::is_reference_

private

Definition at line 60 of file PropertyValue.h.

◆ position_

Position Gaudi::Parsers::PropertyValue::position_

private

Definition at line 59 of file PropertyValue.h.

◆ value_

Value Gaudi::Parsers::PropertyValue::value_

private

Definition at line 58 of file PropertyValue.h.

The documentation for this class was generated from the following files:

GaudiCoreSvc/src/JobOptionsSvc/PropertyValue.h
GaudiCoreSvc/src/JobOptionsSvc/PropertyValue.cpp

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ MapOfStrings

◆ Value

◆ VectorOfStrings

Constructor & Destructor Documentation

◆ PropertyValue() [1/2]

◆ PropertyValue() [2/2]

Member Function Documentation

◆ HasPosition()

◆ IsMap()

◆ IsReference()

◆ IsSimple()

◆ IsVector()

◆ Map() [1/2]

◆ Map() [2/2]

◆ operator+()

◆ operator+=()

◆ operator-()

◆ operator-=()

◆ position()

◆ String() [1/2]

◆ String() [2/2]

◆ ToString()

◆ Vector() [1/2]

◆ Vector() [2/2]

Member Data Documentation

◆ is_reference_

◆ position_

◆ value_