HltStoreSvc.h

Go to the documentation of this file.

#ifndef HLTSTORESVC_H
#define HLTSTORESVC_H
 
#include <iostream>
#include <map>
#include <stdio.h>
#include <string>
 
#include "GaudiKernel/IInterface.h"
#include "GaudiKernel/Service.h"
 
using namespace std;
 
static const InterfaceID IID_IHltStoreSvc( "IID_IHltStoreSvc", 1, 0 );
 
class HltStoreSvc : public Service, virtual public IInterface {
 
public:
  HltStoreSvc( const std::string& name, ISvcLocator* sl );
  ~HltStoreSvc();
 
  virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvIF );
  virtual StatusCode initialize();
  virtual StatusCode finalize();
 
private:
  // HltStoreSvc* m_HltStore;
 
public:
  static const InterfaceID& interfaceID() { return IID_IHltStoreSvc; }
 
protected:
  class BaseHolder;
 
  typedef map<string, BaseHolder*> ContainerType;
 
public:
  void   printKeys();
  int    size();
  int    max_size();
  string sListLength();
  bool   exists( const std::string& name );
 
  //
  // since these are member template functions, we have to
  // put the whole implementation here
  //
 
  //
  // insert a named value into the store: put("name", data)
  // if the key "name" already exists, it is replaced.
  //
 
  template <class T> bool put( const std::string& name, const T& value ) {
    Holder<T>* ptr = new Holder<T>( value );
    if ( BaseHolder* old = m_map[name] )
    {
      std::cout << "demanded key already exists, overwrite old one" << std::endl;
      delete old;
    }
    m_map[name] = ptr;
    return true;
  }
 
  //
  // retrieve a named value from the store: get("name", value)
  // returns false if entry not found; in this case the input
  // object is unchanged
  //
  template <class T> bool get( const std::string& name, T& value ) {
    // std::cout << "HltStoreSvc::get()  "<<"start"<<std::endl;
    ContainerType::iterator it = m_map.find( name );
    // std::cout << "HltStoreSvc::get()  "<<"middle"<<std::endl;
    if ( it != m_map.end() )
    {
      if ( Holder<T>* ptr = static_cast<Holder<T>*>( ( *it ).second ) )
      {
        value = ptr->value();
        return true;
      }
    }
    // std::cout << "HltStoreSvc::get()  "<<"end"<<std::endl;
    return false;
  }
 
  //
  // erase an entry from the store; the corresponding object is
  // destructed automatically or deleted if a pointer
  //
  bool erase( const std::string& name ) {
    ContainerType::iterator it = m_map.find( name );
    if ( it != m_map.end() )
    {
      delete ( *it ).second;
      m_map.erase( it );
      return true;
    }
    return false;
  }
  //
  // clear the store; the corresponding objects are
  // destructed automatically or deleted if a pointer
  //
  bool clear( void ) {
    for ( ContainerType::iterator it = m_map.begin(); it != m_map.end(); it++ )
    { delete ( *it ).second; }
    m_map.erase( m_map.begin(), m_map.end() );
    return true;
  }
 
protected:
  // BaseHolder base class allows the use of a single hash_map for all
  // templated holder classes.
 
  class BaseHolder {
  public:
    virtual ~BaseHolder(){};
  };
 
  template <class T> class Holder : public BaseHolder {
  public:
    Holder( const T& value ) : m_value( value ){};
    ~Holder() { erase( m_value ); }
    const T& value() const { return m_value; }
 
  private:
    template <class T1> void erase( T1 value ) {}
 
    template <class T1> void erase( T1* value ) { delete value; }
 
  private:
    T m_value;
  };
 
  ContainerType m_map;
};
 
#endif