rootana/src/framework/IdSource.h

Go to the documentation of this file.

#ifndef IDSOURCE_H_
#define IDSOURCE_H_

#include "TObject.h"
#include <map>
#include <string>
#include "IdChannel.h"
#include "IdGenerator.h"

namespace IDs{
        class source;
//      class generator;
//      class channel;
}

class IDs::source:public TObject{
 public:
  source()
    : fChannel(),fGenerator() {};

  source(const std::string& s)
    : fChannel(),fGenerator() {
        operator=(s);
    };
    
  source(const IDs::channel& ch,const IDs::generator& gen)
    : fChannel(ch),fGenerator(gen){};
      
  source(const std::string& det, const std::string& type,
         const std::string& gen, const std::string& cfg=IDs::kDefaultConfig)
    : fChannel(det,type), fGenerator(gen,cfg) {};

  source(Detector_t det, SlowFast_t type,const Generator_t& t ,const Config_t& c=IDs::kDefaultConfig)
  :  fChannel(det,type),fGenerator(t,c){};
  
  virtual ~source(){};

  void Reset(){fChannel.Reset(); fGenerator.Reset();}

  bool operator==(const source& rhs)const;
  
  bool operator==(const generator& rhs)const{return fGenerator==rhs;};
  
  bool operator==(const channel& rhs)const{return fChannel==rhs;};

        bool matches(const source& rhs)const;
        bool matches(const generator& rhs)const{return fGenerator.matches(rhs);};
        bool matches(const channel& rhs)const{return fChannel.matches(rhs);};

        bool operator>(const source& rhs)const;
        bool operator<(const source& rhs)const;

  generator& Generator(){return fGenerator;};
  
  channel& Channel(){return fChannel;};
  
  const generator& Generator()const{return fGenerator;};
  
  const channel& Channel()const{return fChannel;};

  std::string str(bool cpp_valid=false)const;

  IDs::source& operator=(const std::string& rhs);

  bool isWildCardChannel() const {return Channel().isWildCard();}

  bool isWildCardGenerator() const {return Generator().isWildCard();}

  bool isWildCard() const 
  {return isWildCardChannel() || isWildCardGenerator();}

  bool isFast() const {return Channel().isFast();};

  bool isSlow() const {return Channel().isSlow();};

  void Debug()const;

 private:
  channel fChannel;
  generator fGenerator;

  ClassDef(source,1);
};

inline bool IDs::source::operator==(const source& rhs)const
{
  return rhs.Generator()==fGenerator && rhs.Channel()==fChannel;
}
inline bool IDs::source::matches(const source& rhs)const{
        return fGenerator.matches(rhs.fGenerator) && fChannel.matches(rhs.fChannel);
}

inline bool IDs::source::operator>(const source& rhs)const
{
  return fChannel>rhs.Channel() || (fChannel==rhs.Channel() && fGenerator > rhs.Generator());
}

inline bool IDs::source::operator<(const source& rhs)const
{
  return fChannel<rhs.Channel() || (fChannel==rhs.Channel() && fGenerator < rhs.Generator());
}

ostream& operator<< (ostream& os ,const IDs::source& id);

#endif // IDSOURCE_H_

// emacs metadata
// Local Variables:
// mode: c++
// End:

---