FloatArrayStore.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TRTCONDITIONSDATA_FLOATARRAYSTORE_H
#define TRTCONDITIONSDATA_FLOATARRAYSTORE_H
/********************************************************************
 
NAME:     FloatArrayStore
PACKAGE:  TRT_ConditionsData
 
AUTHORS:  Jorgen Beck Hansen, Peter Hansen
CREATED:  1/8/05
 
PURPOSE:  Access and manipulate an indexed storage
          
********************************************************************/
 
// INCLUDE HEADER FILES:
 
#include <vector>
#include <map>
#include <string>
#include <functional> //for std::less
#include <iosfwd> // fwd declaration for io classes
#include <cmath> //std::abs
#include "Identifier/Identifier.h"
#include "AthenaKernel/CLASS_DEF.h"

class FloatArrayStore{
public:
 
  typedef std::less<Identifier> lessp;
  typedef std::map<Identifier,int,lessp> BufferMap;
  typedef BufferMap::const_iterator map_citr;
  typedef std::vector< std::vector<float> > Buffer;

  FloatArrayStore();
  FloatArrayStore(const std::string& tag);
  virtual ~FloatArrayStore();
  FloatArrayStore & operator=(FloatArrayStore&& other);
  
  const std::string& tag() const;
  int numberOfIDs() const;
  const std::vector<float>& operator[](const Identifier& ident) const;
  bool sharedID(const Identifier& ident) const;
  bool existID(const Identifier& ident) const;
  void dbg() const;
  map_citr cbegin() const;
  map_citr cend() const;
  
  std::vector<float>& operator[](const Identifier& ident);
  void share(const Identifier& ident, const Identifier& referenceIdent);
  void push_back(const Identifier& ident, const std::vector<float>& value);
  void push_back(const std::vector<Identifier>& identvec, const std::vector<float>& value);
  void removeID(const Identifier& ident);
  void clear();
  void cleanUp();
  map_citr begin() const;
  map_citr end() const;
  const Buffer& buffer() const { return m_buf ; }
  
 
private:
  
  std::string m_tag;                
  BufferMap m_bufmap;               
  Buffer m_buf;                     
  
};
 
CLASS_DEF(FloatArrayStore,170308771,1)
 
// inline methods
inline FloatArrayStore::FloatArrayStore() : m_tag("Undefined") { }
 
inline FloatArrayStore::FloatArrayStore(const std::string& tag) : m_tag(tag) { }
 
inline  FloatArrayStore & FloatArrayStore::operator=(FloatArrayStore&& other){
  if (this!=&other){
    m_tag=std::move(other.m_tag);
    m_bufmap = other.m_bufmap;//can't std::move a map, the keys are const
    m_buf=std::move(other.m_buf);
  }
  return *this;
}
 
 
inline FloatArrayStore::~FloatArrayStore() {}
 
inline void FloatArrayStore::clear() {m_bufmap.clear(); m_buf.clear(); }
 
inline void FloatArrayStore::push_back
     (const Identifier& ident, const std::vector<float>& value){
  m_buf.push_back(value);
  m_bufmap[ident]= m_buf.size()-1;
}
 
inline void FloatArrayStore::push_back(const std::vector<Identifier>& identvec, const std::vector<float>& value){
  m_buf.push_back(value);
  size_t index = m_buf.size()-1;
  for(std::vector<Identifier>::const_iterator it = identvec.begin() ; it != identvec.end(); ++it)
    m_bufmap[*it] = index ;
}
 
inline int FloatArrayStore::numberOfIDs() const
{ return m_bufmap.size(); }
 
inline void FloatArrayStore::removeID(const Identifier& ident)
{ m_bufmap.erase(ident); }
 
inline bool FloatArrayStore::existID(const Identifier& ident) const
{ return m_bufmap.find(ident)!=m_bufmap.end(); }
 
inline bool FloatArrayStore::sharedID(const Identifier& ident) const { return existID(ident)? m_bufmap.find(ident)->second <0 : false; }
 
inline const std::vector<float>& FloatArrayStore::operator[]
(const Identifier& ident) const
{return m_buf[std::abs(m_bufmap.find(ident)->second)]; }
 
inline std::vector<float>& FloatArrayStore::operator[](const Identifier& ident)
  {return m_buf[std::abs(m_bufmap[ident])]; }
 
inline void FloatArrayStore::share
(const Identifier& ident, const Identifier& referenceIdent) {
  if (existID(referenceIdent)){
    m_bufmap[ident] = -std::abs(m_bufmap[referenceIdent]);
    m_bufmap[referenceIdent] = -std::abs(m_bufmap[referenceIdent]);
  }
}
 
inline const std::string& FloatArrayStore::tag() const {return m_tag;}
 
inline  FloatArrayStore::map_citr
 FloatArrayStore::begin() const { return m_bufmap.begin(); }
 
inline  FloatArrayStore::map_citr
 FloatArrayStore::end() const { return m_bufmap.end(); }
 
inline  FloatArrayStore::map_citr
 FloatArrayStore::cbegin() const { return m_bufmap.begin(); }
 
inline  FloatArrayStore::map_citr FloatArrayStore::cend() const { return m_bufmap.end(); }
 
std::ostream& operator<<(std::ostream& os, const FloatArrayStore& store) ;
std::istream& operator>>(std::istream& is, FloatArrayStore& store) ;
 
#endif