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"
#include "FWCore/Utilities/interface/zero_allocator.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, edm::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