---

Track.h

Go to the documentation of this file.

#ifndef Track_h
#define Track_h 1

#include "Node.h"
#include "State.h"
`
class Track {

 public:

  enum TrackType {};

  enum TrackFlag {History};

  enum StateLocation {BeginVelo,EndVelo};

 protected:
  
  TrackType m_type;

  std::map<TrackFlags,int> m_flags;
  
  double m_quality;
  
  size_t m_ndof;

  // State m_state;

  std::map<StateLocation,State> m_states;

  // [optinal: if we agree with Nodes & Clusters ]
  // track owns nodes, it should delete it when reset.
  std::vector<Node*> m_nodes;    

  public:

  Track()
    {reset();}
  
  virtual ~Track()
    {reset();}

  virtual Track* clone() 
    {Track* track = new Track(*this); return track;};
  
  void setType(const TrackType& type)
    {m_type = type;}

  TrackType type() const
    {return m_type;}
  
  // set status
  void setFlag(const TrackFlag& flag, int value) 
    {m_flags[flag] = value;}
  
  int Flag(const TrackFlag& key) const
    {return m_flags.find(key)->second;}
  
  std::map<TrackFlag,int>& flags() 
    {return m_flags;}

  const std::map<TrackFlag,int>& flags() const
    {return m_flags;}

  void setQuality(double quality) 
    {m_quality = quality;}
  
  double quality() const
    {return m_quality;}

  void setNdof(size_t ndof)
      {_ndof = ndof;}

  const size_t ndof() const
    {return m_ndof;}
  
  //  const State& state() const
  //  {return m_state;}

  // State& state() 
  //  {return m_state;}
  
  // [?] what happen if the key is not in the map?
  const State& state(const StateLocation& key) const
    {return m_states.find(key)->second;}

  State& state(const StateLocation& key) 
    {return m_states[key];}

  std::map<StateLocation,state>& states()
    {return m_states;}

  const std::map<StateLocation,state>& states() const
    {return m_states;}

  void setNodes(const std::vector<Node*>& nodes)
    {m_nodes = nodes;}
  
  // [optional: if we consider that there is Nodes and Cluster base classes]
  std::vector<Node*>& nodes()
    {return m_nodes;}
    
  // [optional: if we consider that there is Nodes and Cluster base classes]
  const std::vector<Node*>& nodes() const
    {return m_nodes;}
  
  virtual void clear();
  
  virtual void reset();
  
};


} 
#endif

---