icarus::WeakCurrentType Class Reference

Represents a type of weak current. More...

#include <WeakCurrentType.h>

Public Types
enum	CurrentType { CC, NC, any }
	Type of weak current. More...

Public Member Functions
constexpr	WeakCurrentType ()=default
	Default constructor: matches any current type. More...
constexpr	WeakCurrentType (CurrentType type)
	Constructor: assigns the specified current type. More...
	WeakCurrentType (std::string const &spec)
	operator int () const
String operations
std::string	name () const
std::string	shortName () const
	operator std::string () const
	Converts to the name() of the current. More...
Comparisons
constexpr bool	operator== (WeakCurrentType const &other) const
	Returns whether this current type is the same as the other. More...
constexpr bool	operator!= (WeakCurrentType const &other) const
	Returns whether this current type is different than the other. More...

Static Public Member Functions
static CurrentType	parse (std::string const &spec)
	Converts a string into a WeakCurrentType. More...

Static Private Member Functions
static std::string	to_upper (std::string const &s)
	Returns a upper-case copy of s. More...

Private Attributes
CurrentType	fType = any
	Type of current stored. More...

Detailed Description

Represents a type of weak current.

This type can be initialised with a string (see parse()) or a mnemonic value (CurrentType).

Example of usage:

icarus::WeakCurrentType const current { "neutral" };

std::cout << "Current type: " << std::string(current) << std::endl;
if (current == icarus::NeutralCurrentType) {
  std::cout << "Well, yeah." << std::endl;
}

// use WeakCurrentType::CurrentType in switch statements:
std::string boson;
switch (current) {
  case WeakCurrentType::CC:  boson = "W"; break;
  case WeakCurrentType::NC:  boson = "Z"; break;
  case WeakCurrentType::any: boson = "V"; break;
} // switch

Definition at line 54 of file WeakCurrentType.h.

Member Enumeration Documentation

enum icarus::WeakCurrentType::CurrentType

Type of weak current.

Enumerator
CC	Charged current.
NC	Neutral current.
any	Any interaction.

Definition at line 59 of file WeakCurrentType.h.

                   {
    CC, ///< Charged current.
    NC, ///< Neutral current.
    any ///< Any interaction.
  }; // enum CurrentType

Constructor & Destructor Documentation

constexpr icarus::WeakCurrentType::WeakCurrentType ( )

default

Default constructor: matches any current type.

constexpr icarus::WeakCurrentType::WeakCurrentType ( CurrentType  type )

inline

Constructor: assigns the specified current type.

Definition at line 72 of file WeakCurrentType.h.

: fType(type) {}

icarus::WeakCurrentType::WeakCurrentType ( std::string const &  spec )

inlineexplicit

Constructor: assigns the value interpreting the specification spec.

See Also

WeakCurrentType::parse()

Definition at line 76 of file WeakCurrentType.h.

    : WeakCurrentType(parse(spec)) {}

Member Function Documentation

std::string icarus::WeakCurrentType::name

(

)

const

Returns a string with the name of the current ("charged", "neutral", "any").

Definition at line 34 of file WeakCurrentType.cxx.

                                            {
  
  switch (fType) {
    case CC:  return "charged";
    case NC:  return "neutral";
    case any: return "any";
  } // switch
  throw std::logic_error("icarus::WeakCurrentType::name()");
} // icarus::WeakCurrentType::name()

icarus::WeakCurrentType::operator int ( ) const

inline

Definition at line 119 of file WeakCurrentType.h.

{ return static_cast<int>(fType); }

icarus::WeakCurrentType::operator std::string ( ) const

inline

Converts to the name() of the current.

Definition at line 96 of file WeakCurrentType.h.

{ return name(); }

constexpr bool icarus::WeakCurrentType::operator!= ( WeakCurrentType const &  other ) const

inline

Returns whether this current type is different than the other.

Definition at line 111 of file WeakCurrentType.h.

    { return fType != other.fType; }

constexpr bool icarus::WeakCurrentType::operator== ( WeakCurrentType const &  other ) const

inline

Returns whether this current type is the same as the other.

Definition at line 107 of file WeakCurrentType.h.

    { return fType == other.fType; }

auto icarus::WeakCurrentType::parse ( std::string const &  spec )

static

Converts a string into a WeakCurrentType.

Parameters

spec	the specification string to be converted

Exceptions

cet::exception

(category "WeakCurrentType") if spec is not supported

The case of spec is irrelevant. Accepted values include the shortened name ("CC"; see shortName()), and the full name ("charged"; see name()). Also the empty string is converted to a CurrentType of any.

Definition at line 72 of file WeakCurrentType.cxx.

                                                                      {
  
  std::string const SPEC = to_upper(spec);
  
  if (anyOf(SPEC, { "CHARGED", "CC" })) return CC;
  if (anyOf(SPEC, { "NEUTRAL", "NC" })) return NC;
  if (anyOf(SPEC, { "", "ANY" }))       return any;
  
  throw cet::exception("WeakCurrentType")
    << "Invalid weak current specification: '" << spec << "'\n";
  
} // icarus::WeakCurrentType::parse()

std::string icarus::WeakCurrentType::shortName

(

)

const

Returns a string with the short name of the current ("CC", "NC", "any").

Definition at line 46 of file WeakCurrentType.cxx.

                                                 {
  
  switch (fType) {
    case CC:  return "CC";
    case NC:  return "NC";
    case any: return "any";
  } // switch
  throw std::logic_error("icarus::WeakCurrentType::shortName()");
  
} // icarus::WeakCurrentType::shortName()

std::string icarus::WeakCurrentType::to_upper ( std::string const &  s )

staticprivate

Returns a upper-case copy of s.

Definition at line 59 of file WeakCurrentType.cxx.

                                                            {
  
  std::string S;
  S.reserve(s.size());
  
  auto char_toupper = [](unsigned char c){ return std::toupper(c); };
  std::transform(s.begin(), s.end(), std::back_inserter(S), char_toupper);
  
  return S;
} // icarus::WeakCurrentType::to_upper()

Member Data Documentation

CurrentType icarus::WeakCurrentType::fType = any

private

Type of current stored.

Definition at line 138 of file WeakCurrentType.h.

---

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

• WeakCurrentType.h
• WeakCurrentType.cxx