DDMapper< KeyType, ValueType > Class Template Reference

#include <DDMapper.h>

Public Types
typedef std::pair< KeyType, ValueType >	Pair
	usefull typedef More...
typedef std::vector< Pair >	Vector
	usefull typedef More...

Public Member Functions
Vector	all (const std::string &name, const std::string &value) const
	get all std::mapped instances which have a specific 'name' with value 'value' More...
Vector	all (const std::string &name, const double &value) const
	get all std::mapped instances which have a specific 'name' with value 'value' More...
Vector	all (const std::string &name) const
	get all std::mapped instances which have a specific 'name' More...
void	insert (const KeyType &, const ValueType &)
	insert a new key-value-pair More...
unsigned int	noSpecifics (const KeyType &key, const std::string &name) const
	fetch a key given a value More...
unsigned int	toDouble (const std::string &name, const KeyType &key, double &value, unsigned int pos=0) const
	returns the number specific parameters named 'name' and the corrsponding double More...
unsigned int	toDouble (const std::string &name, const ValueType &key, double &value, unsigned int pos=0) const
unsigned int	toString (const std::string &name, const KeyType &key, std::string &value, unsigned int pos=0) const
	same as toDouble but for std::string-valued values of named parameters More...
unsigned int	toString (const std::string &name, const ValueType &key, std::string &value, unsigned int pos=0) const
	same as toDouble but for std::string-valued values of named parameters More...
bool	value (const KeyType &key, ValueType &result)
	removes a key-value pair More...

Private Attributes
std::map< KeyType, ValueType >	keyToValue_
std::multimap< ValueType, KeyType >	valueToKey_

Detailed Description

template<class KeyType, class ValueType>
class DDMapper< KeyType, ValueType >

Definition at line 13 of file DDMapper.h.

Member Typedef Documentation

Pair

template<class KeyType, class ValueType>

typedef std::pair<KeyType, ValueType> DDMapper< KeyType, ValueType >::Pair

usefull typedef

Definition at line 16 of file DDMapper.h.

Vector

template<class KeyType, class ValueType>

typedef std::vector<Pair> DDMapper< KeyType, ValueType >::Vector

usefull typedef

Definition at line 19 of file DDMapper.h.

Member Function Documentation

all() [1/3]

template<class K , class V >

std::vector< std::pair< K, V > > DDMapper< K, V >::all	(	const std::string &	name,
		const std::string &	value
	)		const

get all std::mapped instances which have a specific 'name' with value 'value'

Definition at line 199 of file DDMapper.h.

Referenced by DDG4ProductionCuts::initialize().

                                                                                                 {
  std::vector<std::pair<K, V> > result;
  typedef std::vector<const DDsvalues_type *> sv_type;
  typename std::map<V, K>::const_iterator it = valueToKey_.begin();
  typename std::map<V, K>::const_iterator ed = valueToKey_.end();

  // loop over all registered ValueTypes
  for (; it != ed; ++it) {
    sv_type sv = it->first.specifics();
    //std::cout << "now at: " << it->first.name() << std::endl;
    sv_type::const_iterator svIt = sv.begin();
    sv_type::const_iterator svEd = sv.end();
    DDValue v(name);
    for (; svIt != svEd; ++svIt) {
      if (DDfetch(*svIt, v)) {
        //std::cout << "found: ";
        const std::vector<std::string> &s = v.strings();
        if (!s.empty()) {
          //std::cout << s[0];
          if (s[0] == value) {
            result.emplace_back(std::make_pair(it->second, it->first));
            break;
          }
        }
        //std::cout << std::endl;
      }
    }
  }
  return result;
}

all() [2/3]

template<class K , class V >

std::vector< std::pair< K, V > > DDMapper< K, V >::all	(	const std::string &	name,
		const double &	value
	)		const

get all std::mapped instances which have a specific 'name' with value 'value'

Definition at line 231 of file DDMapper.h.

                                                                                              {
  std::vector<std::pair<K, V> > result;
  typedef std::vector<const DDsvalues_type *> sv_type;
  typename std::map<V, K>::const_iterator it = valueToKey_.begin();
  typename std::map<V, K>::const_iterator ed = valueToKey_.end();

  // loop over all registered ValueTypes
  for (; it != ed; ++it) {
    sv_type sv = it->first.specifics();
    //std::cout << "now at: " << it->first.name() << std::endl;
    sv_type::const_iterator svIt = sv.begin();
    sv_type::const_iterator svEd = sv.end();
    DDValue v(name);
    for (; svIt != svEd; ++svIt) {
      if (DDfetch(*svIt, v)) {
        //std::cout << "found: ";
        const std::vector<double> &s = v.doubles();
        if (!s.empty()) {
          //std::cout << s[0];
          if (s[0] == value) {
            result.emplace_back(std::make_pair(it->second, it->first));
            break;
          }
        }
        //std::cout << std::endl;
      }
    }
  }
  return result;
}

all() [3/3]

template<class K , class V >

std::vector< std::pair< K, V > > DDMapper< K, V >::all

(

const std::string &

name

)

const

get all std::mapped instances which have a specific 'name'

Definition at line 263 of file DDMapper.h.

                                                                         {
  std::vector<std::pair<K, V> > result;
  typedef std::vector<const DDsvalues_type *> sv_type;
  typename std::map<V, K>::const_iterator it = valueToKey_.begin();
  typename std::map<V, K>::const_iterator ed = valueToKey_.end();

  // loop over all registered ValueTypes
  for (; it != ed; ++it) {
    sv_type sv = it->first.specifics();
    //std::cout << "now at: " << it->first.name() << std::endl;
    sv_type::const_iterator svIt = sv.begin();
    sv_type::const_iterator svEd = sv.end();
    DDValue v(name);
    for (; svIt != svEd; ++svIt) {
      if (DDfetch(*svIt, v)) {
        result.emplace_back(std::make_pair(it->second, it->first));
        break;
      }
    }
  }
  return result;
}

insert()

template<class K, class V>

void DDMapper< K, V >::insert	(	const K &	key,
		const V &	value
	)

insert a new key-value-pair

any existing entry will be overridden

Definition at line 74 of file DDMapper.h.

Referenced by SequenceTypes.Schedule::_replaceIfHeldDirectly(), BeautifulSoup.PageElement::append(), DDG4Builder::BuildGeometry(), and DDG4Builder::convertLV().

                                                        {
  keyToValue_[key] = value;
  valueToKey_.insert(std::make_pair(value, key));
  //   valueToKey_[value] = key;
}

noSpecifics()

template<class K, class V >

unsigned int DDMapper< K, V >::noSpecifics	(	const K &	key,
		const std::string &	name
	)		const

fetch a key given a value

the number of specific parameters which are named 'name'

Definition at line 92 of file DDMapper.h.

                                                                                  {
  typedef std::vector<const DDsvalues_type *> sv_type;
  unsigned int result = 0;
  typename std::map<K, V>::const_iterator it = keyToValue_.find(key);
  if (it != keyToValue_.end()) {
    sv_type sv = it->second.specifics();
    sv_type::const_iterator it = sv.begin();
    DDValue v(name);
    for (; it != sv.end(); ++it) {
      if (DDfetch(*it, v)) {
        result += v.size();
      }
    }
  }
  return result;
}

toDouble() [1/2]

template<class K, class V >

unsigned int DDMapper< K, V >::toDouble	(	const std::string &	name,
		const K &	key,
		double &	value,
		unsigned int	pos = 0
	)		const

returns the number specific parameters named 'name' and the corrsponding double

of the DDLogicalPart which corresponds to the given KeyType key. The returned value is assigned to the 'value'-reference

• if no parameters exist, 0 is returned and value is left unchanged
• if more than one parameter with the given name exists, the first is returned by default, alternatively 'pos' can be used to address another value (note: pos=0 -> first value)

Definition at line 111 of file DDMapper.h.

Referenced by DDG4ProductionCuts::setProdCuts().

                                                                                                                {
  typedef std::vector<const DDsvalues_type *> sv_type;
  unsigned int result = 0;
  typename std::map<K, V>::const_iterator it = keyToValue_.find(key);
  if (it != keyToValue_.end()) {
    sv_type sv = it->second.specifics();
    sv_type::const_iterator svIt = sv.begin();
    sv_type::const_iterator svEd = sv.end();
    DDValue v(name);
    for (; svIt != svEd; ++svIt) {
      if (DDfetch(*svIt, v)) {
        result = v.size();
        value = v.doubles()[pos];
        break;
      }
    }
  }
  return result;
}

toDouble() [2/2]

template<class K , class V>

unsigned int DDMapper< K, V >::toDouble	(	const std::string &	name,
		const V &	key,
		double &	value,
		unsigned int	pos = 0
	)		const

Definition at line 132 of file DDMapper.h.

                                                                                                                {
  typedef std::vector<const DDsvalues_type *> sv_type;
  unsigned int result = 0;
  sv_type sv = val.specifics();
  sv_type::const_iterator svIt = sv.begin();
  sv_type::const_iterator svEd = sv.end();
  DDValue v(name);
  for (; svIt != svEd; ++svIt) {
    if (DDfetch(*svIt, v)) {
      result = v.size();
      value = v.doubles()[pos];
      break;
    }
  }
  return result;
}

toString() [1/2]

template<class K, class V >

unsigned int DDMapper< K, V >::toString	(	const std::string &	name,
		const K &	key,
		std::string &	value,
		unsigned int	pos = 0
	)		const

same as toDouble but for std::string-valued values of named parameters

Definition at line 172 of file DDMapper.h.

Referenced by DDG4ProductionCuts::initialize().

                                                              {
  typedef std::vector<const DDsvalues_type *> sv_type;
  unsigned int result = 0;
  typename std::map<K, V>::const_iterator it = keyToValue_.find(key);
  if (it != keyToValue_.end()) {
    sv_type sv = it->second.specifics();
    sv_type::const_iterator svIt = sv.begin();
    sv_type::const_iterator svEd = sv.end();
    DDValue v(name);
    //std::cout << "DDValue=" << name << std::endl;
    for (; svIt != svEd; ++svIt) {
      //std::cout << "looping..." << **svIt << std::endl;
      if (DDfetch(*svIt, v)) {
        result = v.size();
        //std::cout << "found!" << std::endl;
        value = v.strings()[pos];
        break;
      }
    }
  }
  return result;
}

toString() [2/2]

template<class K, class V>

unsigned int DDMapper< K, V >::toString	(	const std::string &	name,
		const V &	key,
		std::string &	value,
		unsigned int	pos = 0
	)		const

same as toDouble but for std::string-valued values of named parameters

Definition at line 150 of file DDMapper.h.

                                                              {
  typedef std::vector<const DDsvalues_type *> sv_type;
  unsigned int result = 0;
  sv_type sv = val.specifics();
  sv_type::const_iterator svIt = sv.begin();
  sv_type::const_iterator svEd = sv.end();
  DDValue v(name);
  for (; svIt != svEd; ++svIt) {
    if (DDfetch(*svIt, v)) {
      result = v.size();
      value = v.strings()[pos];
      break;
    }
  }
  return result;
}

value()

template<class K, class V>

bool DDMapper< K, V >::value	(	const K &	key,
		V &	result
	)

removes a key-value pair

non-existing keys are simply ignored removes a key-value pair non-existing values are simply ignored fetch a value given a key returns true, if sucessfull - value is assigned to result; else false

Definition at line 81 of file DDMapper.h.

Referenced by Types.int32::__nonzero__(), Types.uint32::__nonzero__(), Types.int64::__nonzero__(), Types.uint64::__nonzero__(), Types.double::__nonzero__(), Types.bool::__nonzero__(), Types.string::__nonzero__(), average.Average::average(), Types.string::configValue(), Types.FileInPath::configValue(), Mixins.UsingBlock::dumpPython(), 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.FileInPath::insertInto(), Types.vint32::insertInto(), Types.vuint32::insertInto(), Types.vint64::insertInto(), Types.vuint64::insertInto(), Types.vdouble::insertInto(), Types.vbool::insertInto(), and Types.vstring::insertInto().

                                                 {
  bool result = false;
  typename std::map<K, V>::const_iterator it = keyToValue_.find(key);
  if (it != keyToValue_.end()) {
    value = it->second;
    result = true;
  }
  return result;
}

Member Data Documentation

keyToValue_

template<class KeyType, class ValueType>

std::map<KeyType, ValueType> DDMapper< KeyType, ValueType >::keyToValue_

private

Definition at line 69 of file DDMapper.h.

valueToKey_

template<class KeyType, class ValueType>

std::multimap<ValueType, KeyType> DDMapper< KeyType, ValueType >::valueToKey_

private

Definition at line 70 of file DDMapper.h.