---

TrNode.h

Go to the documentation of this file.

//   **************************************************************************
//   *                                                                        *
//   *                      ! ! ! A T T E N T I O N ! ! !                     *
//   *                                                                        *
//   *  This file was created automatically by GaudiObjDesc, please do not    *
//   *  delete it or edit it by hand.                                         *
//   *                                                                        *
//   *  If you want to change this file, first change the corresponding       *
//   *  xml-file and rerun the tools from GaudiObjDesc (or run make if you    *
//   *  are using it from inside a Gaudi-package).                            *
//   *                                                                        *
//   **************************************************************************



#ifndef TrEvent_TrNode_H
#define TrEvent_TrNode_H 1

// Include files
#include "Kernel/CLHEPStreams.h"
#include "GaudiKernel/ObjectList.h"
#include "GaudiKernel/ObjectVector.h"
#include "GaudiKernel/StreamBuffer.h"
#include "Event/TrMeasurement.h"


class TrNode
{

public: 

  enum Type {OTMeasurement,STMeasurement,TTMeasurement,VeloRMeasurement,VeloPhiMeasurement};   

  TrNode() 
    : m_type(0),
    m_residual(0.0),
    m_errResidual(0.0),
    m_measurement() {}

  virtual ~TrNode() {}

  virtual TrNode* clone() const;

  int type() const; 

  void setType(int value);

  double residual() const; 

  void setResidual(double value);

  double errResidual() const; 

  void setErrResidual(double value);

  const TrMeasurement* measurement() const; 

  TrMeasurement* measurement();

  void setMeasurement(TrMeasurement* value);

  friend StreamBuffer& operator<< (StreamBuffer& s, const TrNode& obj)
  {
    return obj.serialize(s);
  }

  friend StreamBuffer& operator>> (StreamBuffer& s, TrNode& obj)
  {
    return obj.serialize(s);
  }

  friend std::ostream& operator<< (std::ostream& s, const TrNode& obj)
  {
    return obj.fillStream(s);
  }

  virtual StreamBuffer& serialize(StreamBuffer& s) const;

  virtual StreamBuffer& serialize(StreamBuffer& s);

  virtual std::ostream& fillStream(std::ostream& s) const;

protected: 

private: 

  int            m_type;        
  double         m_residual;    
  double         m_errResidual; 
  TrMeasurement* m_measurement; 

};

// -----------------------------------------------------------------------------
//   end of class
// -----------------------------------------------------------------------------


inline int TrNode::type() const 
{
  return m_type;
}

inline void TrNode::setType(int value)
{
  m_type = value; 
}

inline double TrNode::residual() const 
{
  return m_residual;
}

inline void TrNode::setResidual(double value)
{
  m_residual = value; 
}

inline double TrNode::errResidual() const 
{
  return m_errResidual;
}

inline void TrNode::setErrResidual(double value)
{
  m_errResidual = value; 
}

inline const TrMeasurement* TrNode::measurement() const 
{
  return m_measurement;
}

inline TrMeasurement* TrNode::measurement()
{
  return m_measurement;
}

inline void TrNode::setMeasurement(TrMeasurement* value)
{
  m_measurement = value; 
}

inline StreamBuffer& TrNode::serialize(StreamBuffer& s) const 
{
  s << m_type
    << (float)m_residual
    << (float)m_errResidual
    << m_measurement;
  return s;
}

inline StreamBuffer& TrNode::serialize(StreamBuffer& s)
{
  float l_residual, l_errResidual;
  s >> m_type
    >> l_residual
    >> l_errResidual
    >> m_measurement;
  m_residual = l_residual;
  m_errResidual = l_errResidual;
  return s;
}

inline std::ostream& TrNode::fillStream(std::ostream& s) const
{
  s << "{ "
    << " type:\t" << m_type << std::endl
    << "   residual:\t" << (float)m_residual << std::endl
    << "   errResidual:\t" << (float)m_errResidual << std::endl
    << "   measurement:\t" << m_measurement << " } ";
  return s;
}


#endif   

---