edm::Entry Class Reference

#include <Entry.h>

Public Member Functions
	Entry (std::string const &name, bool val, bool is_tracked)
	Entry (std::string const &name, int val, bool is_tracked)
	Entry (std::string const &name, std::vector< int > const &val, bool is_tracked)
	Entry (std::string const &name, unsigned val, bool is_tracked)
	Entry (std::string const &name, std::vector< unsigned > const &val, bool is_tracked)
	Entry (std::string const &name, long long val, bool is_tracked)
	Entry (std::string const &name, std::vector< long long > const &val, bool is_tracked)
	Entry (std::string const &name, unsigned long long val, bool is_tracked)
	Entry (std::string const &name, std::vector< unsigned long long > const &val, bool is_tracked)
	Entry (std::string const &name, double val, bool is_tracked)
	Entry (std::string const &name, std::vector< double > const &val, bool is_tracked)
	Entry (std::string const &name, std::string const &val, bool is_tracked)
	Entry (std::string const &name, std::vector< std::string > const &val, bool is_tracked)
	Entry (std::string const &name, FileInPath const &val, bool is_tracked)
	Entry (std::string const &name, InputTag const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< InputTag > const &vtag, bool is_tracked)
	Entry (std::string const &name, ESInputTag const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< ESInputTag > const &vtag, bool is_tracked)
	Entry (std::string const &name, EventID const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< EventID > const &vtag, bool is_tracked)
	Entry (std::string const &name, LuminosityBlockID const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< LuminosityBlockID > const &vtag, bool is_tracked)
	Entry (std::string const &name, LuminosityBlockRange const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< LuminosityBlockRange > const &vtag, bool is_tracked)
	Entry (std::string const &name, EventRange const &tag, bool is_tracked)
	Entry (std::string const &name, std::vector< EventRange > const &vtag, bool is_tracked)
	Entry (std::string const &name, ParameterSet const &val, bool is_tracked)
	Entry (std::string const &name, std::vector< ParameterSet > const &val, bool is_tracked)
	Entry (std::string name, std::string_view)
	Entry (std::string name, std::string_view type, std::string_view value, bool is_tracked)
	Entry (std::string name, std::string_view type, std::vector< std::string > const &value, bool is_tracked)
	Entry (Entry const &)=default
	Entry (Entry &&)=default
bool	getBool () const
double	getDouble () const
ESInputTag	getESInputTag () const
EventID	getEventID () const
EventRange	getEventRange () const
FileInPath	getFileInPath () const
InputTag	getInputTag () const
int	getInt32 () const
long long	getInt64 () const
LuminosityBlockID	getLuminosityBlockID () const
LuminosityBlockRange	getLuminosityBlockRange () const
ParameterSet	getPSet () const
std::string	getString () const
unsigned	getUInt32 () const
unsigned long long	getUInt64 () const
std::vector< double >	getVDouble () const
std::vector< ESInputTag >	getVESInputTag () const
std::vector< EventID >	getVEventID () const
std::vector< EventRange >	getVEventRange () const
std::vector< InputTag >	getVInputTag () const
std::vector< int >	getVInt32 () const
std::vector< long long >	getVInt64 () const
std::vector< LuminosityBlockID >	getVLuminosityBlockID () const
std::vector< LuminosityBlockRange >	getVLuminosityBlockRange () const
std::vector< ParameterSet >	getVPSet () const
std::vector< std::string >	getVString () const
std::vector< unsigned >	getVUInt32 () const
std::vector< unsigned long long >	getVUInt64 () const
bool	isTracked () const
Entry &	operator= (Entry const &)=default
Entry &	operator= (Entry &&)=default
size_t	sizeOfString () const
void	toDigest (cms::Digest &digest) const
std::string	toString () const
void	toString (std::string &result) const
char	typeCode () const
	~Entry ()=default

Static Public Member Functions
static std::string_view	bounds (std::string_view, std::size_t iEndHint)

Private Member Functions
bool	fromString (std::string_view::const_iterator b, std::string_view::const_iterator e)
void	throwEncodeError (char const *type) const
void	throwEntryError (char const *expectedType, std::string const &badRep) const
void	throwValueError (char const *expectedType) const
void	validate () const

Private Attributes
std::string	name_
std::string	rep_
char	tracked_
char	type_

Friends
std::ostream &	operator<< (std::ostream &ost, Entry const &entry)

Detailed Description

Definition at line 40 of file Entry.h.

Constructor & Destructor Documentation

Entry() [1/33]

Entry::Entry	(	std::string const &	name,
		bool	val,
		bool	is_tracked
	)

Definition at line 432 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTbool), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("bool");
    validate();
  }

Entry() [2/33]

Entry::Entry	(	std::string const &	name,
		int	val,
		bool	is_tracked
	)

Definition at line 442 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTint32), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("int");
    validate();
  }

Entry() [3/33]

Entry::Entry	(	std::string const &	name,
		std::vector< int > const &	val,
		bool	is_tracked
	)

Definition at line 452 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvint32), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<int>");
    validate();
  }

Entry() [4/33]

Entry::Entry	(	std::string const &	name,
		unsigned	val,
		bool	is_tracked
	)

Definition at line 462 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTuint32), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("unsigned int");
    validate();
  }

Entry() [5/33]

Entry::Entry	(	std::string const &	name,
		std::vector< unsigned > const &	val,
		bool	is_tracked
	)

Definition at line 472 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvuint32), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<unsigned int>");
    validate();
  }

Entry() [6/33]

Entry::Entry	(	std::string const &	name,
		long long	val,
		bool	is_tracked
	)

Definition at line 482 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTint64), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("int64");
    validate();
  }

Entry() [7/33]

Entry::Entry	(	std::string const &	name,
		std::vector< long long > const &	val,
		bool	is_tracked
	)

Definition at line 492 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvint64), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<int64>");
    validate();
  }

Entry() [8/33]

Entry::Entry	(	std::string const &	name,
		unsigned long long	val,
		bool	is_tracked
	)

Definition at line 502 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTuint64), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("unsigned int64");
    validate();
  }

Entry() [9/33]

Entry::Entry	(	std::string const &	name,
		std::vector< unsigned long long > const &	val,
		bool	is_tracked
	)

Definition at line 512 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvuint64), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<unsigned int64>");
    validate();
  }

Entry() [10/33]

Entry::Entry	(	std::string const &	name,
		double	val,
		bool	is_tracked
	)

Definition at line 522 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTdouble), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("double");
    validate();
  }

Entry() [11/33]

Entry::Entry	(	std::string const &	name,
		std::vector< double > const &	val,
		bool	is_tracked
	)

Definition at line 532 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvdouble), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<double>");
    validate();
  }

Entry() [12/33]

Entry::Entry	(	std::string const &	name,
		std::string const &	val,
		bool	is_tracked
	)

Definition at line 542 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTstringRaw), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("string");
    validate();
  }

Entry() [13/33]

Entry::Entry	(	std::string const &	name,
		std::vector< std::string > const &	val,
		bool	is_tracked
	)

Definition at line 552 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvstringRaw), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<string>");
    validate();
  }

Entry() [14/33]

Entry::Entry	(	std::string const &	name,
		FileInPath const &	val,
		bool	is_tracked
	)

Definition at line 562 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTFileInPath), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("FileInPath");
    validate();
  }

Entry() [15/33]

Entry::Entry	(	std::string const &	name,
		InputTag const &	tag,
		bool	is_tracked
	)

Definition at line 572 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTInputTag), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("InputTag");
    validate();
  }

Entry() [16/33]

Entry::Entry	(	std::string const &	name,
		std::vector< InputTag > const &	vtag,
		bool	is_tracked
	)

Definition at line 582 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVInputTag), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VInputTag");
    validate();
  }

Entry() [17/33]

Entry::Entry	(	std::string const &	name,
		ESInputTag const &	tag,
		bool	is_tracked
	)

Definition at line 592 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTESInputTag), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("InputTag");
    validate();
  }

Entry() [18/33]

Entry::Entry	(	std::string const &	name,
		std::vector< ESInputTag > const &	vtag,
		bool	is_tracked
	)

Definition at line 602 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVESInputTag), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VESInputTag");
    validate();
  }

Entry() [19/33]

Entry::Entry	(	std::string const &	name,
		EventID const &	tag,
		bool	is_tracked
	)

Definition at line 612 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTEventID), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("EventID");
    validate();
  }

Entry() [20/33]

Entry::Entry	(	std::string const &	name,
		std::vector< EventID > const &	vtag,
		bool	is_tracked
	)

Definition at line 622 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVEventID), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VEventID");
    validate();
  }

Entry() [21/33]

Entry::Entry	(	std::string const &	name,
		LuminosityBlockID const &	tag,
		bool	is_tracked
	)

Definition at line 632 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTLuminosityBlockID), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("LuminosityBlockID");
    validate();
  }

Entry() [22/33]

Entry::Entry	(	std::string const &	name,
		std::vector< LuminosityBlockID > const &	vtag,
		bool	is_tracked
	)

Definition at line 642 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVLuminosityBlockID), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VLuminosityBlockID");
    validate();
  }

Entry() [23/33]

Entry::Entry	(	std::string const &	name,
		LuminosityBlockRange const &	tag,
		bool	is_tracked
	)

Definition at line 652 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTLuminosityBlockRange), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("LuminosityBlockRange");
    validate();
  }

Entry() [24/33]

Entry::Entry	(	std::string const &	name,
		std::vector< LuminosityBlockRange > const &	vtag,
		bool	is_tracked
	)

Definition at line 662 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVLuminosityBlockRange), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VLuminosityBlockRange");
    validate();
  }

Entry() [25/33]

Entry::Entry	(	std::string const &	name,
		EventRange const &	tag,
		bool	is_tracked
	)

Definition at line 672 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTEventRange), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("EventRange");
    validate();
  }

Entry() [26/33]

Entry::Entry	(	std::string const &	name,
		std::vector< EventRange > const &	vtag,
		bool	is_tracked
	)

Definition at line 682 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTVEventRange), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("VEventRange");
    validate();
  }

Entry() [27/33]

Entry::Entry	(	std::string const &	name,
		ParameterSet const &	val,
		bool	is_tracked
	)

Definition at line 692 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTPSet), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("ParameterSet");
    validate();
  }

Entry() [28/33]

Entry::Entry	(	std::string const &	name,
		std::vector< ParameterSet > const &	val,
		bool	is_tracked
	)

Definition at line 702 of file Entry.cc.

References edm::encode(), rep_, throwEncodeError(), heppy_batch::val, and validate().

      : name_(name), rep_(), type_(kTvPSet), tracked_(is_tracked ? '+' : '-') {
    if (!encode(rep_, val))
      throwEncodeError("vector<ParameterSet>");
    validate();
  }

Entry() [29/33]

Entry::Entry	(	std::string	name,
		std::string_view	code
	)

Definition at line 712 of file Entry.cc.

References fromString(), throwEncodeError(), and validate().

                                                  : name_(std::move(name)), rep_(), type_('?'), tracked_('?') {
    if (!fromString(code.begin(), code.end()))
      throwEncodeError("coded string");
    validate();
  }

Entry() [30/33]

Entry::Entry	(	std::string	name,
		std::string_view	type,
		std::string_view	value,
		bool	is_tracked
	)

Definition at line 718 of file Entry.cc.

References codeFromType(), edm::errors::Configuration, Exception, fromString(), AlCaHLTBitMon_QueryRunRegistry::string, findQualityFiles::v, validate(), and relativeConstraints::value.

      : name_(std::move(name)), rep_(), type_('?'), tracked_('?') {
    std::string codedString(is_tracked ? "-" : "+");

    codedString += codeFromType(type);
    codedString += '(';
    codedString += value;
    codedString += ')';

    std::string_view v = codedString;
    if (!fromString(v.begin(), v.end())) {
      throw Exception(errors::Configuration) << "bad encoded Entry string " << codedString;
    }
    validate();
  }

Entry() [31/33]

Entry::Entry	(	std::string	name,
		std::string_view	type,
		std::vector< std::string > const &	value,
		bool	is_tracked
	)

Definition at line 734 of file Entry.cc.

References codeFromType(), edm::errors::Configuration, MillePedeFileConverter_cfg::e, Exception, fromString(), mps_fire::i, AlCaHLTBitMon_QueryRunRegistry::string, findQualityFiles::v, and validate().

      : name_(std::move(name)), rep_(), type_('?'), tracked_('?') {
    std::string codedString(is_tracked ? "-" : "+");

    codedString += codeFromType(type);
    codedString += '(';
    codedString += '{';
    std::vector<std::string>::const_iterator i = value.begin();
    std::vector<std::string>::const_iterator e = value.end();
    std::string const kSeparator(",");
    std::string sep("");
    for (; i != e; ++i) {
      codedString += sep;
      codedString += *i;
      sep = kSeparator;
    }
    codedString += '}';
    codedString += ')';

    std::string_view v = codedString;
    if (!fromString(v.begin(), v.end())) {
      throw Exception(errors::Configuration) << "bad encoded Entry string " << codedString;
    }
    validate();
  }

~Entry()

edm::Entry::~Entry ( )

default

Entry() [32/33]

edm::Entry::Entry ( Entry const &  )

default

Entry() [33/33]

edm::Entry::Entry ( Entry &&  )

default

Member Function Documentation

bounds()

std::string_view Entry::bounds ( std::string_view  iView, std::size_t  iEndHint  )

static

Definition at line 760 of file Entry.cc.

References edm::decode_pset_extent(), edm::decode_string_extent(), edm::decode_vpset_extent(), edm::decode_vstring_extent(), kTPSet, kTstringRaw, kTvPSet, and kTvstringRaw.

Referenced by edm::ParameterSet::extent(), and edm::ParameterSet::fromString().

                                                                       {
    if (iView.size() < 4) {
      return {};
    }
    if (iView[1] == kTPSet) {
      auto extent = edm::decode_pset_extent(iView.substr(3));
      if (not extent) {
        return {};
      }
      return iView.substr(0, extent->size() + 3 + 1);
    } else if (iView[1] == kTvPSet) {
      auto extent = edm::decode_vpset_extent(iView.substr(3));
      if (not extent) {
        return {};
      }
      return iView.substr(0, extent->size() + 3 + 1);
    } else if (iView[1] != kTstringRaw and iView[1] != kTvstringRaw) {
      return iView.substr(0, iEndHint);
    }
    if (iView[1] == kTstringRaw) {
      // is of the form
      // [trackiness][type](...\0)[endHintChar]
      // where decode returns the ...\0 part
      auto extent = edm::decode_string_extent(iView.substr(3));
      if (not extent) {
        return {};
      }
      return iView.substr(0, extent->size() + 3 + 1);
    }
    // is of the form
    // [trackiness][type]({...})[endHitChar]
    // where decode returns the {...} part
    auto extent = edm::decode_vstring_extent(iView.substr(3));
    if (not extent) {
      return {};
    }
    return iView.substr(0, extent->size() + 3 + 1);
  }

fromString()

bool Entry::fromString ( std::string_view::const_iterator  b, std::string_view::const_iterator  e  )

private

Definition at line 828 of file Entry.cc.

References b, MillePedeFileConverter_cfg::e, rep_, AlCaHLTBitMon_QueryRunRegistry::string, tracked_, and type_.

Referenced by Entry().

                                                                                                   {
    if (static_cast<unsigned int>(e - b) < 4u || b[2] != '(' || e[-1] != ')')

      return false;

    tracked_ = b[0];
    type_ = b[1];
    rep_ = std::string(b + 3, e - 1);

    return true;
  }  // from_string()

getBool()

bool Entry::getBool

(

)

const

Definition at line 847 of file Entry.cc.

References edm::decode(), kTbool, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                            {
    if (type_ != kTbool)
      throwValueError("bool");
    bool val;
    if (!decode(val, rep_))
      throwEntryError("bool", rep_);
    return val;
  }

getDouble()

double Entry::getDouble

(

)

const

Definition at line 955 of file Entry.cc.

References edm::decode(), kTdouble, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                {
    if (type_ != kTdouble)
      throwValueError("double");
    double val;
    if (!decode(val, rep_))
      throwEntryError("double", rep_);
    return val;
  }

getESInputTag()

ESInputTag Entry::getESInputTag

(

)

const

Definition at line 1048 of file Entry.cc.

References edm::decode(), kTESInputTag, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                        {
    if (type_ != kTESInputTag)
      throwValueError("ESInputTag");
    ESInputTag val;
    if (!decode(val, rep_))
      throwEntryError("ESInputTag", rep_);
    return val;
  }

getEventID()

EventID Entry::getEventID

(

)

const

Definition at line 1072 of file Entry.cc.

References edm::decode(), kTEventID, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                  {
    if (type_ != kTEventID)
      throwValueError("EventID");
    EventID val;
    if (!decode(val, rep_))
      throwEntryError("EventID", rep_);
    return val;
  }

getEventRange()

EventRange Entry::getEventRange

(

)

const

Definition at line 1143 of file Entry.cc.

References edm::decode(), kTEventRange, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                        {
    if (type_ != kTEventRange)
      throwValueError("EventRange");
    EventRange val;
    if (!decode(val, rep_))
      throwEntryError("EventRange", rep_);
    return val;
  }

getFileInPath()

FileInPath Entry::getFileInPath

(

)

const

Definition at line 1012 of file Entry.cc.

References edm::decode(), kTFileInPath, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                        {
    if (type_ != kTFileInPath)
      throwValueError("FileInPath");
    FileInPath val;
    if (!decode(val, rep_))
      throwEntryError("FileInPath", rep_);
    return val;
  }

getInputTag()

InputTag Entry::getInputTag

(

)

const

Definition at line 1024 of file Entry.cc.

References edm::decode(), kTInputTag, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter().

                                    {
    if (type_ != kTInputTag)
      throwValueError("InputTag");
    InputTag val;
    if (!decode(val, rep_))
      throwEntryError("InputTag", rep_);
    return val;
  }

getInt32()

int Entry::getInt32

(

)

const

Definition at line 859 of file Entry.cc.

References edm::decode(), kTint32, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                            {
    if (type_ != kTint32)
      throwValueError("int");
    int val;
    if (!decode(val, rep_))
      throwEntryError("int", rep_);
    return val;
  }

getInt64()

long long Entry::getInt64

(

)

const

Definition at line 883 of file Entry.cc.

References edm::decode(), kTint64, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                  {
    if (type_ != kTint64)
      throwValueError("int64");
    long long val;
    if (!decode(val, rep_))
      throwEntryError("int64", rep_);
    return val;
  }

getLuminosityBlockID()

LuminosityBlockID Entry::getLuminosityBlockID

(

)

const

Definition at line 1096 of file Entry.cc.

References edm::decode(), kTLuminosityBlockID, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                                      {
    if (type_ != kTLuminosityBlockID)
      throwValueError("LuminosityBlockID");
    LuminosityBlockID val;
    if (!decode(val, rep_))
      throwEntryError("LuminosityBlockID", rep_);
    return val;
  }

getLuminosityBlockRange()

LuminosityBlockRange Entry::getLuminosityBlockRange

(

)

const

Definition at line 1119 of file Entry.cc.

References edm::decode(), kTLuminosityBlockRange, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                                            {
    if (type_ != kTLuminosityBlockRange)
      throwValueError("LuminosityBlockRange");
    LuminosityBlockRange val;
    if (!decode(val, rep_))
      throwEntryError("LuminosityBlockRange", rep_);
    return val;
  }

getPSet()

ParameterSet Entry::getPSet

(

)

const

Definition at line 1168 of file Entry.cc.

References edm::decode(), kTPSet, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

                                    {
    if (type_ != kTPSet)
      throwValueError("ParameterSet");
    ParameterSet val;
    if (!decode(val, rep_))
      throwEntryError("ParameterSet", rep_);
    return val;
  }

getString()

std::string Entry::getString

(

void

)

const

Definition at line 979 of file Entry.cc.

References edm::decode(), edm::decode_deprecated(), kTstringHex, kTstringRaw, rep_, AlCaHLTBitMon_QueryRunRegistry::string, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getParameter(), and edm::ParameterSet::getUntrackedParameter< std::string >().

                                   {
    if (type_ != kTstringRaw and type_ != kTstringHex)
      throwValueError("string");
    std::string val;
    if (type_ == kTstringHex) {
      if (!decode_deprecated(val, rep_)) {
        throwEntryError("string", rep_);
      }
    } else if (!decode(val, rep_)) {
      throwEntryError("string", rep_);
    }
    return val;
  }

getUInt32()

unsigned Entry::getUInt32

(

)

const

Definition at line 907 of file Entry.cc.

References edm::decode(), kTuint32, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                  {
    if (type_ != kTuint32)
      throwValueError("unsigned int");
    unsigned val;
    if (!decode(val, rep_))
      throwEntryError("unsigned int", rep_);
    return val;
  }

getUInt64()

unsigned long long Entry::getUInt64

(

)

const

Definition at line 931 of file Entry.cc.

References edm::decode(), kTuint64, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter().

                                            {
    if (type_ != kTuint64)
      throwValueError("uint64");
    unsigned long long val;
    if (!decode(val, rep_))
      throwEntryError("uint64", rep_);
    return val;
  }

getVDouble()

std::vector< double > Entry::getVDouble

(

)

const

Definition at line 967 of file Entry.cc.

References edm::decode(), kTvdouble, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< double > >().

                                            {
    if (type_ != kTvdouble)
      throwValueError("vector<double>");
    std::vector<double> val;
    if (!decode(val, rep_))
      throwEntryError("vector<double>", rep_);
    return val;
  }

getVESInputTag()

std::vector< ESInputTag > Entry::getVESInputTag

(

)

const

Definition at line 1060 of file Entry.cc.

References edm::decode(), kTVESInputTag, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< ESInputTag > >().

                                                    {
    if (type_ != kTVESInputTag)
      throwValueError("VESInputTag");
    std::vector<ESInputTag> val;
    if (!decode(val, rep_))
      throwEntryError("VESInputTag", rep_);
    return val;
  }

getVEventID()

std::vector< EventID > Entry::getVEventID

(

)

const

Definition at line 1084 of file Entry.cc.

References edm::decode(), kTVEventID, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< EventID > >().

                                              {
    if (type_ != kTVEventID)
      throwValueError("VEventID");
    std::vector<EventID> val;
    if (!decode(val, rep_))
      throwEntryError("EventID", rep_);
    return val;
  }

getVEventRange()

std::vector< EventRange > Entry::getVEventRange

(

)

const

Definition at line 1155 of file Entry.cc.

References edm::decode(), kTVEventRange, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< EventRange > >().

                                                    {
    if (type_ != kTVEventRange)
      throwValueError("VEventRange");
    std::vector<EventRange> val;
    if (!decode(val, rep_))
      throwEntryError("EventRange", rep_);
    return val;
  }

getVInputTag()

std::vector< InputTag > Entry::getVInputTag

(

)

const

Definition at line 1036 of file Entry.cc.

References edm::decode(), kTVInputTag, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< InputTag > >().

                                                {
    if (type_ != kTVInputTag)
      throwValueError("VInputTag");
    std::vector<InputTag> val;
    if (!decode(val, rep_))
      throwEntryError("VInputTag", rep_);
    return val;
  }

getVInt32()

std::vector< int > Entry::getVInt32

(

)

const

Definition at line 871 of file Entry.cc.

References edm::decode(), kTvint32, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< int > >().

                                        {
    if (type_ != kTvint32)
      throwValueError("vector<int>");
    std::vector<int> val;
    if (!decode(val, rep_))
      throwEntryError("vector<int>", rep_);
    return val;
  }

getVInt64()

std::vector< long long > Entry::getVInt64

(

)

const

Definition at line 895 of file Entry.cc.

References edm::decode(), kTvint64, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< long long > >().

                                              {
    if (type_ != kTvint64)
      throwValueError("vector<int64>");
    std::vector<long long> val;
    if (!decode(val, rep_))
      throwEntryError("vector<int64>", rep_);
    return val;
  }

getVLuminosityBlockID()

std::vector< LuminosityBlockID > Entry::getVLuminosityBlockID

(

)

const

Definition at line 1108 of file Entry.cc.

References edm::decode(), kTVLuminosityBlockID, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockID > >().

                                                                  {
    if (type_ != kTVLuminosityBlockID)
      throwValueError("VLuminosityBlockID");
    std::vector<LuminosityBlockID> val;
    if (!decode(val, rep_))
      throwEntryError("LuminosityBlockID", rep_);
    return val;
  }

getVLuminosityBlockRange()

std::vector< LuminosityBlockRange > Entry::getVLuminosityBlockRange

(

)

const

Definition at line 1131 of file Entry.cc.

References edm::decode(), kTVLuminosityBlockRange, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< LuminosityBlockRange > >().

                                                                        {
    if (type_ != kTVLuminosityBlockRange)
      throwValueError("VLuminosityBlockRange");
    std::vector<LuminosityBlockRange> val;
    if (!decode(val, rep_))
      throwEntryError("LuminosityBlockRange", rep_);
    return val;
  }

getVPSet()

std::vector< ParameterSet > Entry::getVPSet

(

)

const

Definition at line 1180 of file Entry.cc.

References edm::decode(), kTvPSet, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

                                                {
    if (type_ != kTvPSet)
      throwValueError("vector<ParameterSet>");
    std::vector<ParameterSet> val;
    if (!decode(val, rep_))
      throwEntryError("vector<ParameterSet>", rep_);
    return val;
  }

getVString()

std::vector< std::string > Entry::getVString

(

)

const

Definition at line 996 of file Entry.cc.

References edm::decode(), edm::decode_deprecated(), kTvstringHex, kTvstringRaw, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< std::string > >().

                                               {
    if (type_ != kTvstringRaw and type_ != kTvstringHex)
      throwValueError("vector<string>");
    std::vector<std::string> val;
    if (type_ == kTvstringHex) {
      if (!decode_deprecated(val, rep_))
        throwEntryError("vector<string>", rep_);
    } else if (!decode(val, rep_)) {
      throwEntryError("vector<string>", rep_);
    }
    return val;
  }

getVUInt32()

std::vector< unsigned > Entry::getVUInt32

(

)

const

Definition at line 919 of file Entry.cc.

References edm::decode(), kTvuint32, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< unsigned int > >().

                                              {
    if (type_ != kTvuint32)
      throwValueError("vector<unsigned int>");
    std::vector<unsigned> val;
    if (!decode(val, rep_))
      throwEntryError("vector<unsigned int>", rep_);
    return val;
  }

getVUInt64()

std::vector< unsigned long long > Entry::getVUInt64

(

)

const

Definition at line 943 of file Entry.cc.

References edm::decode(), kTvuint64, rep_, throwEntryError(), throwValueError(), type_, and heppy_batch::val.

Referenced by edm::ParameterSet::getUntrackedParameter< std::vector< unsigned long long > >().

                                                        {
    if (type_ != kTvuint64)
      throwValueError("vector<uint64>");
    std::vector<unsigned long long> val;
    if (!decode(val, rep_))
      throwEntryError("vector<uint64>", rep_);
    return val;
  }

isTracked()

bool edm::Entry::isTracked ( ) const

inline

Definition at line 174 of file Entry.h.

References tracked_.

Referenced by Types.PSet::clone(), Mixins._ParameterTypeBase::configTypeName(), Mixins.UsingBlock::insertInto(), Types.int32::insertInto(), Types.uint32::insertInto(), Types.int64::insertInto(), Types.uint64::insertInto(), Types.double::insertInto(), Types.bool::insertInto(), Types.string::insertInto(), Types.EventID::insertInto(), Types.LuminosityBlockID::insertInto(), Types.LuminosityBlockRange::insertInto(), Types.EventRange::insertInto(), Types.InputTag::insertInto(), Types.ESInputTag::insertInto(), Types.FileInPath::insertInto(), Types.PSet::insertInto(), Types.vint32::insertInto(), Types.vuint32::insertInto(), Types.vint64::insertInto(), Types.vuint64::insertInto(), Types.vdouble::insertInto(), Types.vbool::insertInto(), Types.vstring::insertInto(), Types.VLuminosityBlockID::insertInto(), Types.VInputTag::insertInto(), Types.VESInputTag::insertInto(), Types.VEventID::insertInto(), Types.VLuminosityBlockRange::insertInto(), Types.VEventRange::insertInto(), Types.VPSet::insertInto(), and Mixins._ParameterTypeBase::pythonTypeName().

{ return tracked_ == '+'; }

operator=() [1/2]

Entry& edm::Entry::operator= ( Entry const &  )

default

operator=() [2/2]

Entry& edm::Entry::operator= ( Entry &&  )

default

sizeOfString()

size_t edm::Entry::sizeOfString ( ) const

inline

Definition at line 171 of file Entry.h.

References rep_.

Referenced by toString().

{ return rep_.size() + 4; }

throwEncodeError()

void Entry::throwEncodeError ( char const *  type ) const

private

Definition at line 1308 of file Entry.cc.

References edm::errors::Configuration, Exception, and name_.

Referenced by Entry().

                                                     {
    throw Exception(errors::Configuration, "EncodingError") << "can not encode " << name_ << " as type: " << type;
  }

throwEntryError()

void Entry::throwEntryError ( char const *  expectedType, std::string const &  badRep  ) const

private

Definition at line 1303 of file Entry.cc.

References edm::errors::Configuration, Exception, and name_.

Referenced by getBool(), getDouble(), getESInputTag(), getEventID(), getEventRange(), getFileInPath(), getInputTag(), getInt32(), getInt64(), getLuminosityBlockID(), getLuminosityBlockRange(), getPSet(), getString(), getUInt32(), getUInt64(), getVDouble(), getVESInputTag(), getVEventID(), getVEventRange(), getVInputTag(), getVInt32(), getVInt64(), getVLuminosityBlockID(), getVLuminosityBlockRange(), getVPSet(), getVString(), getVUInt32(), getVUInt64(), and validate().

                                                                                     {
    throw Exception(errors::Configuration, "EntryError") << "can not convert representation of " << name_ << ": "
                                                         << badRep << " to value of type " << expectedType << " ";
  }

throwValueError()

void Entry::throwValueError ( char const *  expectedType ) const

private

Definition at line 1298 of file Entry.cc.

References edm::errors::Configuration, Exception, name_, type_, and typeFromCode().

Referenced by getBool(), getDouble(), getESInputTag(), getEventID(), getEventRange(), getFileInPath(), getInputTag(), getInt32(), getInt64(), getLuminosityBlockID(), getLuminosityBlockRange(), getPSet(), getString(), getUInt32(), getUInt64(), getVDouble(), getVESInputTag(), getVEventID(), getVEventRange(), getVInputTag(), getVInt32(), getVInt64(), getVLuminosityBlockID(), getVLuminosityBlockRange(), getVPSet(), getVString(), getVUInt32(), and getVUInt64().

                                                            {
    throw Exception(errors::Configuration, "ValueError")
        << "type of " << name_ << " is expected to be " << expectedType << " but declared as " << typeFromCode(type_);
  }

toDigest()

void Entry::toDigest

(

cms::Digest &

digest

)

const

Definition at line 812 of file Entry.cc.

References cms::Digest::append(), rep_, tracked_, and type_.

                                              {
    digest.append(&tracked_, 1);
    digest.append(&type_, 1);
    digest.append("(", 1);
    digest.append(rep_);
    digest.append(")", 1);
  }

toString() [1/2]

std::string Entry::toString

(

)

const

Definition at line 820 of file Entry.cc.

References mps_fire::result, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by egHLT::trigTools::getMinNrObjsRequiredByFilter(), and edm::ParameterSet::getParameterAsString().

                                  {
    std::string result;
    toString(result);
    return result;
  }

toString() [2/2]

void Entry::toString

(

std::string &

result

)

const

Definition at line 803 of file Entry.cc.

References rep_, mps_fire::result, sizeOfString(), tracked_, and type_.

                                              {
    result.reserve(result.size() + sizeOfString());
    result += tracked_;
    result += type_;
    result += '(';
    result += rep_;
    result += ')';
  }

typeCode()

char edm::Entry::typeCode ( ) const

inline

Definition at line 176 of file Entry.h.

References type_.

Referenced by edm::ParameterSet::getParameter(), and edm::ParameterSet::getParameterNamesForType().

{ return type_; }

validate()

void Entry::validate ( ) const

private

Definition at line 220 of file Entry.cc.

References cms::cuda::assert(), edm::errors::Configuration, edm::decode(), edm::decode_deprecated(), Exception, kTbool, kTdouble, kTESInputTag, kTEventID, kTEventRange, kTFileInPath, kTInputTag, kTint32, kTint64, kTLuminosityBlockID, kTLuminosityBlockRange, kTPSet, kTstringHex, kTstringRaw, kTuint32, kTuint64, kTvBool, kTvdouble, kTVESInputTag, kTVEventID, kTVEventRange, kTVInputTag, kTvint32, kTvint64, kTVLuminosityBlockID, kTVLuminosityBlockRange, kTvPSet, kTvstringHex, kTvstringRaw, kTvuint32, kTvuint64, rep_, AlCaHLTBitMon_QueryRunRegistry::string, throwEntryError(), tracked_, type_, and heppy_batch::val.

Referenced by Entry().

                             {
    // tracked
    assert(tracked_ == '+' || tracked_ == '-');
    //     if(tracked_ != '+' && tracked_ != '-')
    //       throw EntryError(std::string("invalid tracked code ") + tracked_);

    // type and rep
    switch (type_) {
      case kTbool: {  // Bool
        bool val;
        if (!decode(val, rep_))
          throwEntryError("bool", rep_);
        break;
      }
      case kTvBool: {  // vBool
        std::vector<bool> val;
        if (!decode(val, rep_))
          throwEntryError("vector<bool>", rep_);
        break;
      }
      case kTint32: {  // Int32
        int val;
        if (!decode(val, rep_))
          throwEntryError("int", rep_);
        break;
      }
      case kTvint32: {  // vInt32
        std::vector<int> val;
        if (!decode(val, rep_))
          throwEntryError("vector<int>", rep_);
        break;
      }
      case kTuint32: {  // Uint32
        unsigned val;
        if (!decode(val, rep_))
          throwEntryError("unsigned int", rep_);
        break;
      }
      case kTvuint32: {  // vUint32
        std::vector<unsigned> val;
        if (!decode(val, rep_))
          throwEntryError("vector<unsigned int>", rep_);
        break;
      }
      case kTint64: {  // Int64
        long long int val;
        if (!decode(val, rep_))
          throwEntryError("int64", rep_);
        break;
      }
      case kTvint64: {  // vInt64
        std::vector<long long int> val;
        if (!decode(val, rep_))
          throwEntryError("vector<int64>", rep_);
        break;
      }
      case kTuint64: {  // Uint64
        unsigned long long int val;
        if (!decode(val, rep_))
          throwEntryError("unsigned int64", rep_);
        break;
      }
      case kTvuint64: {  // vUint64
        std::vector<unsigned long long int> val;
        if (!decode(val, rep_))
          throwEntryError("vector<unsigned int64>", rep_);
        break;
      }
      case kTstringRaw: {  // String
        std::string val;
        if (!decode(val, rep_))
          throwEntryError("string", rep_);
        break;
      }
      case kTvstringRaw: {  // vString
        std::vector<std::string> val;
        if (!decode(val, rep_))
          throwEntryError("vector<string>", rep_);
        break;
      }
      case kTstringHex: {  // String
        std::string val;
        if (!decode_deprecated(val, rep_))
          throwEntryError("string_hex", rep_);
        break;
      }
      case kTvstringHex: {  // vString
        std::vector<std::string> val;
        if (!decode_deprecated(val, rep_))
          throwEntryError("vector<string_hex>", rep_);
        break;
      }

      case kTFileInPath: {  // FileInPath
        FileInPath val;
        if (!decode(val, rep_))
          throwEntryError("FileInPath", rep_);
        break;
      }
      case kTInputTag: {  // InputTag
        InputTag val;
        if (!decode(val, rep_))
          throwEntryError("InputTag", rep_);
        break;
      }
      case kTVInputTag: {  // VInputTag
        std::vector<InputTag> val;
        if (!decode(val, rep_))
          throwEntryError("VInputTag", rep_);
        break;
      }
      case kTESInputTag: {  //ESInputTag
        ESInputTag val;
        if (!decode(val, rep_))
          throwEntryError("ESInputTag", rep_);
        break;
      }
      case kTVESInputTag: {  //ESInputTag
        std::vector<ESInputTag> val;
        if (!decode(val, rep_))
          throwEntryError("VESInputTag", rep_);
        break;
      }
      case kTEventID: {  // EventID
        EventID val;
        if (!decode(val, rep_))
          throwEntryError("EventID", rep_);
        break;
      }
      case kTVEventID: {  // VEventID
        std::vector<EventID> val;
        if (!decode(val, rep_))
          throwEntryError("VEventID", rep_);
        break;
      }
      case kTLuminosityBlockID: {  // LuminosityBlockID
        LuminosityBlockID val;
        if (!decode(val, rep_))
          throwEntryError("LuminosityBlockID", rep_);
        break;
      }
      case kTVLuminosityBlockID: {  // VLuminosityBlockID
        std::vector<LuminosityBlockID> val;
        if (!decode(val, rep_))
          throwEntryError("VLuminosityBlockID", rep_);
        break;
      }
      case kTdouble: {  // Double
        double val;
        if (!decode(val, rep_))
          throwEntryError("double", rep_);
        break;
      }
      case kTvdouble: {  // vDouble
        std::vector<double> val;
        if (!decode(val, rep_))
          throwEntryError("vector<double>", rep_);
        break;
      }
      case kTPSet: {  // ParameterSet
        ParameterSet val;
        if (!decode(val, rep_))
          throwEntryError("ParameterSet", rep_);
        break;
      }
      case kTvPSet: {  // vParameterSet
        std::vector<ParameterSet> val;
        if (!decode(val, rep_))
          throwEntryError("vector<ParameterSet>", rep_);
        break;
      }
      case kTLuminosityBlockRange: {  // LuminosityBlockRange
        LuminosityBlockRange val;
        if (!decode(val, rep_))
          throwEntryError("LuminosityBlockRange", rep_);
        break;
      }
      case kTVLuminosityBlockRange: {  // VLuminosityBlockRange
        std::vector<LuminosityBlockRange> val;
        if (!decode(val, rep_))
          throwEntryError("VLuminosityBlockRange", rep_);
        break;
      }
      case kTEventRange: {  // EventRange
        EventRange val;
        if (!decode(val, rep_))
          throwEntryError("EventRange", rep_);
        break;
      }
      case kTVEventRange: {  // VEventRange
        std::vector<EventRange> val;
        if (!decode(val, rep_))
          throwEntryError("VEventRange", rep_);
        break;
      }
      default: {
        // We should never get here.
        throw edm::Exception(edm::errors::Configuration) << "Unknown ParameterSet Entry type encoding: '" << type_
                                                         << "'.\n This could be caused by reading a file which was "
                                                            "written using a newer incompatible software release.";
        break;
      }
    }  // switch(type)
  }    // Entry::validate()

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  ost, Entry const &  entry  )

friend

Definition at line 1189 of file Entry.cc.

                                                             {
    os << typeFromCode(entry.typeCode()) << " " << (entry.isTracked() ? "tracked " : "untracked ") << " = ";

    // now handle the difficult cases
    switch (entry.typeCode()) {
      case kTPSet:  // ParameterSet
      {
        os << entry.getPSet();
        break;
      }
      case 'p':  // vector<ParameterSet>
      {
        // Make sure we get the representation of each contained
        // ParameterSet including *only* tracked parameters
        std::vector<ParameterSet> whole = entry.getVPSet();
        std::vector<ParameterSet>::const_iterator i = whole.begin();
        std::vector<ParameterSet>::const_iterator e = whole.end();
        std::string start = "";
        std::string const between(",\n");
        os << "{" << std::endl;
        for (; i != e; ++i) {
          os << start << *i;
          start = between;
        }
        if (!whole.empty()) {
          os << std::endl;
        }
        os << "}";
        break;
      }
      case kTstringRaw: {
        os << "'" << entry.getString() << "'";
        break;
      }
      case kTvstringRaw: {
        os << "{";
        std::string_view start = "'";
        std::string_view const between(",'");
        std::vector<std::string> strings = entry.getVString();
        for (auto const& s : strings) {
          os << start << s << "'";
          start = between;
        }
        os << "}";
        break;
      }
      case kTstringHex: {
        os << "'" << entry.getString() << "'";
        break;
      }
      case kTvstringHex: {
        os << "{";
        std::string_view start = "'";
        std::string_view const between(",'");
        std::vector<std::string> strings = entry.getVString();
        for (auto const& s : strings) {
          os << start << s << "'";
          start = between;
        }
        os << "}";
        break;
      }
      case kTint32: {
        os << entry.getInt32();
        break;
      }
      case kTuint32: {
        os << entry.getUInt32();
        break;
      }
      case kTVInputTag: {
        //VInputTag needs to be treated seperately because it is encode like
        // vector<string> rather than using the individual encodings of each InputTag
        os << "{";
        std::string start = "";
        std::string const between(",");
        std::vector<InputTag> tags = entry.getVInputTag();
        for (std::vector<InputTag>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it) {
          os << start << it->encode();
          start = between;
        }
        os << "}";
        break;
      }
      case kTVESInputTag: {
        //VESInputTag needs to be treated seperately because it is encode like
        // vector<string> rather than using the individual encodings of each ESInputTag
        os << "{";
        std::string start = "";
        std::string const between(",");
        std::vector<ESInputTag> tags = entry.getVESInputTag();
        for (std::vector<ESInputTag>::const_iterator it = tags.begin(), itEnd = tags.end(); it != itEnd; ++it) {
          os << start << it->encode();
          start = between;
        }
        os << "}";
        break;
      }
      default: {
        os << entry.rep_;
        break;
      }
    }

    return os;
  }

Member Data Documentation

name_

std::string edm::Entry::name_

private

Definition at line 184 of file Entry.h.

Referenced by throwEncodeError(), throwEntryError(), and throwValueError().

rep_

std::string edm::Entry::rep_

private

Definition at line 185 of file Entry.h.

Referenced by Entry(), fromString(), getBool(), getDouble(), getESInputTag(), getEventID(), getEventRange(), getFileInPath(), getInputTag(), getInt32(), getInt64(), getLuminosityBlockID(), getLuminosityBlockRange(), getPSet(), getString(), getUInt32(), getUInt64(), getVDouble(), getVESInputTag(), getVEventID(), getVEventRange(), getVInputTag(), getVInt32(), getVInt64(), getVLuminosityBlockID(), getVLuminosityBlockRange(), getVPSet(), getVString(), getVUInt32(), getVUInt64(), sizeOfString(), toDigest(), toString(), and validate().

tracked_

char edm::Entry::tracked_

private

Definition at line 187 of file Entry.h.

Referenced by fromString(), isTracked(), toDigest(), toString(), and validate().

type_

char edm::Entry::type_

private

Definition at line 186 of file Entry.h.

Referenced by Modules.Service::__str__(), Modules.Service::_placeImpl(), Modules.ESSource::_placeImpl(), Modules.ESProducer::_placeImpl(), Modules.ESPrefer::copy(), Mixins._TypedParameterizable::dumpPython(), Modules.ESPrefer::dumpPythonAs(), Modules.Service::dumpSequencePython(), fromString(), getBool(), getDouble(), getESInputTag(), getEventID(), getEventRange(), getFileInPath(), getInputTag(), getInt32(), getInt64(), getLuminosityBlockID(), getLuminosityBlockRange(), getPSet(), getString(), getUInt32(), getUInt64(), getVDouble(), getVESInputTag(), getVEventID(), getVEventRange(), getVInputTag(), getVInt32(), getVInt64(), getVLuminosityBlockID(), getVLuminosityBlockRange(), getVPSet(), getVString(), getVUInt32(), getVUInt64(), RandomRunSource.RandomRunSource::insertInto(), Modules.Service::insertInto(), ExternalGeneratorFilter.ExternalGeneratorFilter::insertInto(), Mixins._TypedParameterizable::insertInto(), Modules.ESSource::moduleLabel_(), Modules.ESProducer::moduleLabel_(), Modules.ESSource::nameInProcessDesc_(), Modules.ESProducer::nameInProcessDesc_(), Modules.ESPrefer::nameInProcessDesc_(), throwValueError(), toDigest(), toString(), typeCode(), and validate().