DataItem.h

Go to the documentation of this file.

#ifndef ANP_DATAITEM_H
#define ANP_DATAITEM_H

// $Id: DataItem.h,v 1.14 2008/02/22 22:07:16 rustem Exp $
//
// Template for (key, data) pair
//

// C++
#include <iostream>
#include <string>
#include <vector>

// ROOT
#include "Rtypes.h"

namespace Anp
{   
   template<class K, class D>
   class DataItem
   {
   public:
      
      DataItem();
      DataItem(const K key_, const D data_);     
      ~DataItem();

      void Set(const K key_, const D data_);
      void SetData(const D data_);
      void SetKey(const K key_);

      D Data() const;
      K Key()  const;

   private:

      K key;
      D data;
   };

   template<class K, class D>
      bool operator < (const DataItem<K, D> &lhs, const DataItem<K, D> &rhs);

   template<class K, class D>
      bool operator < (const DataItem<K, D> &lhs, const K &rhs);
   
   template<class K, class D>
      bool operator < (const K &lhs, const DataItem<K, D> &rhs);

   template<class K, class D>
      bool operator == (const DataItem<K, D> &lhs, const DataItem<K, D> &rhs);

   template<class K, class D>
      bool operator == (const DataItem<K, D> &lhs, const K &rhs);
   
   template<class K, class D>
      bool operator == (const K &lhs, const DataItem<K, D> &rhs);

   //------------------------------------------------------------------------
   // typedefs for commonly used types
   //------------------------------------------------------------------------
   typedef DataItem<std::string, Float_t> StringData;
   typedef DataItem<Short_t, Float_t> Data;
   typedef std::vector<Anp::Data> DataVec;
   typedef DataVec::const_iterator DataIter;
   typedef DataVec::iterator DataIterator;

   std::ostream &operator<<(std::ostream& os, const Data &data);

   //------------------------------------------------------------------------
   // Inlined member functions
   //------------------------------------------------------------------------
   template<class K, class D> DataItem<K, D>::DataItem() {}
   template<class K, class D> DataItem<K, D>::DataItem(const K key_, const D data_) 
      :key(key_),
       data(data_)
   {
   }     

   template<class K, class D> DataItem<K, D>::~DataItem() {}

   template<class K, class D> void DataItem<K, D>::Set(const K key_, const D data_)
   { 
      key  = key_;
      data = data_;
   }
   template<class K, class D> void DataItem<K, D>::SetData(const D data_)
   { 
      data = data_;
   }
   template<class K, class D> void DataItem<K, D>::SetKey(const K key_)
   { 
      key  = key_;
   }

   template<class K, class D> D DataItem<K, D>::Data() const { return data; }
   template<class K, class D> K DataItem<K, D>::Key()  const { return key; }

   //------------------------------------------------------------------------
   // Inlined global functions
   //------------------------------------------------------------------------
   template<class K, class D>
      inline bool operator < (const DataItem<K, D> &lhs, const DataItem<K, D> &rhs)
   {
      return (lhs.Key() < rhs.Key());
   }

   template<class K, class D>
      inline bool operator < (const DataItem<K, D> &lhs, const K &rhs)
   {
      return (lhs.Key() < rhs);
   }
   
   template<class K, class D>
      inline bool operator < (const K &lhs, const DataItem<K, D> &rhs)
   {
      return (lhs < rhs.Key());
   }

   template<class K, class D>
      inline bool operator == (const DataItem<K, D> &lhs, const DataItem<K, D> &rhs)
   {
      return (lhs.Key() == rhs.Key());
   }

   template<class K, class D>
      inline bool operator == (const DataItem<K, D> &lhs, const K &rhs)
   {
      return (lhs.Key() == rhs);
   }
   
   template<class K, class D>
      inline bool operator == (const K &lhs, const DataItem<K, D> &rhs)
   {
      return (lhs == rhs.Key());
   }

   inline std::ostream &operator<<(std::ostream& os, const Data &data)
   {
      os  << "data[" << data.Key() << "]=" << data.Data();
      return os;
   }
}

#endif

---