DDValue.h

Go to the documentation of this file.

#ifndef DDValue_h
#define DDValue_h
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <memory>

#include "DetectorDescription/Core/interface/DDValuePair.h"
#include "DetectorDescription/Base/interface/Ptr.h"

#include "boost/shared_ptr.hpp"

class DDValue;
class DDSpecifics;
class DDLSpecPar;

//std::ostream & operator<< ( std::ostream &, const DDValue &);
class DDValue //: public std::vector<DDValuePair>
{
  friend class DDSpecifics;
  friend class DDLSpecPar;
public:
  DDValue() : id_(0), vecPair_(0) { }
  
  DDValue(const std::string &);

  DDValue(const char *);
 
  void init(const std::string &);
 
  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() { destroy(); }
  //DDValue(const DDValue &);
  //DDValue & operator=(const DDValue &);
  //const DDValuePair &  
  
  ~DDValue();
  
  unsigned int id() const { return id_; }
  
  operator unsigned int() const { return id_; }
  
  const std::string & name() const { return names()[id_]; }
  
  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 ; 
  } 
  
  static void clear();
  
  void setEvalState(bool newState); 
  

  bool isEvaluated() const;
  

  bool operator==(const DDValue & v) const;
  /* {
    return id()==v.id() 
      && ( 
      vecPair_ == v.vecPair_ || 
      (
       vecPair_ && v.vecPair_ &&
       ( (vecPair_->first) ? (vecPair_->second.second == v.vecPair_->second.second) 
         : (vecPair_->second.first == v.vecPair_->second.first) 
         )
       )
       )
  }
  */
  
  bool operator<(const DDValue &) const;
  /*{
    return id()<v.id() || 
      (
       id()==v.id() && 
       vecPair_ && v.vecPair_ &&
       ( (vecPair_->first) ? (vecPair_->second.second < v.vecPair_->second.second) 
     : (vecPair_->second.first < v.vecPair_->second.first)
     )
       )
  }
  */
  
private:  
  typedef std::pair<bool, std::pair<std::vector<std::string>, std::vector<double> > >vecpair_type;
  static std::vector<std::string>& names();
  static std::map<std::string,unsigned int>& indexer();
  static std::vector<boost::shared_ptr<vecpair_type> >& mem(vecpair_type*);
  //DDValue(const DDValue &);
  //DDValue & operator=(const DDValue &);
  //void destroy() { delete vecPair_;} //delete valPairs_; }
  
  //static std::vector<std::map<std::string,unsigned int>::const_iterator> names_;
  unsigned int id_;
  
  //Ptr<vecpair_type>  vecPair_;
public:  
  vecpair_type* vecPair_;

public:  
  //bool isEvaluated_;
  //auto_ptr<vecpair_type> vecPair_;
  //std::vector<DDValuePair> * valPairs_;
};


std::ostream & operator<<(std::ostream & o, const DDValue & v);
#endif // DDValue_h