DDValue.h

Go to the documentation of this file.

#ifndef DetectorDescription_Core_DDValue_h
#define DetectorDescription_Core_DDValue_h

#include <iostream>
#include <string>
#include <vector>
#include <memory>
#include <atomic>
#include "tbb/concurrent_vector.h"
#include "tbb/concurrent_unordered_map.h"

#include "DetectorDescription/Core/interface/DDValuePair.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 );
  
  ~DDValue( void );
  
  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