DDValue.h

Go to the documentation of this file.

#ifndef DetectorDescription_Core_DDValue_h
#define DetectorDescription_Core_DDValue_h
 
#include <atomic>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "DetectorDescription/Core/interface/DDValuePair.h"
#include "tbb/concurrent_unordered_map.h"
#include "tbb/concurrent_vector.h"
 
class DDValue {
public:
  DDValue(void) : id_(0), vecPair_() {}
 
  explicit DDValue(const std::string&);
 
  explicit DDValue(const char*);
 
  explicit DDValue(const std::string&, const std::vector<DDValuePair>&);
 
  explicit DDValue(const std::string&, double);
 
  explicit DDValue(const std::string&, const std::string&, double);
 
  explicit DDValue(const std::string& name, const std::string& val);
 
  explicit DDValue(unsigned int);
 
  unsigned int id(void) const { return id_; }
 
  operator unsigned int(void) const { return id_; }
 
  const std::string& name(void) const { return *(names()[id_].string_); }
 
  DDValuePair operator[](unsigned int i) const;
 
  const std::vector<std::string>& strings() const { return vecPair_->second.first; }
 
  const std::vector<double>& doubles() const;
  //const DDValuePair & operator[](unsigned int i) const { return (*valPairs_)[i]  ; }
 
  unsigned int size() const { return vecPair_ ? vecPair_->second.first.size() : 0; }
 
  void setEvalState(bool newState);
 
 
  bool isEvaluated(void) const;
 
 
  bool operator==(const DDValue& v) const;
 
  bool operator<(const DDValue&) const;
 
private:
  struct StringHolder {
    StringHolder() {}
    explicit StringHolder(std::string iString) : string_(new std::string{std::move(iString)}) {}
    explicit StringHolder(StringHolder const& iOther) : string_(new std::string{*(iOther.string_)}) {}
    StringHolder& operator=(const StringHolder&) = delete;
    ~StringHolder() { delete string_.load(); }
 
    std::atomic<std::string*> string_;
  };
  struct AtomicUInt {
    AtomicUInt(unsigned int iValue) : value_(iValue) {}
    AtomicUInt() {}
    AtomicUInt(const AtomicUInt& iOther) : value_(iOther.value_.load()) {}
    AtomicUInt& operator=(const AtomicUInt& iOther) {
      value_ = iOther.value_.load();
      return *this;
    }
 
    std::atomic<unsigned int> value_;
  };
 
  void init(const std::string&);
 
  using Names = tbb::concurrent_vector<StringHolder, tbb::zero_allocator<StringHolder>>;
  static Names& names();
  static Names initializeNames();
 
  using NamesToIndicies = tbb::concurrent_unordered_map<std::string, AtomicUInt>;
  static NamesToIndicies& indexer();
 
  unsigned int id_;
  using vecpair_type = std::pair<bool, std::pair<std::vector<std::string>, std::vector<double>>>;
  std::shared_ptr<vecpair_type> vecPair_;
};
 
std::ostream& operator<<(std::ostream& o, const DDValue& v);
 
#endif  // DetectorDescription_Core_DDValue_h