EventContainers::InternalOffline Class Reference

#include <InternalOffline.h>

Inheritance diagram for EventContainers::InternalOffline:

Collaboration diagram for EventContainers::InternalOffline:

Public Types
typedef EventContainers::hashPair< void >	hashPair
typedef std::vector< hashPair >::const_iterator	InternalConstItr
typedef void	deleter_f(const void *p)

Public Member Functions
	InternalOffline (size_t max)
virtual	~InternalOffline ()=default
virtual InternalConstItr	cbegin () const override
virtual InternalConstItr	cend () const override
virtual InternalConstItr	indexFind (IdentifierHash hashId) const override
virtual const std::vector< hashPair > &	getAllHashPtrPair () const override
virtual bool	tryAddFromCache (IdentifierHash hashId, EventContainers::IDC_WriteHandleBase &lock) override
virtual bool	tryAddFromCache (IdentifierHash hashId) override
virtual void	wait () const override
virtual std::vector< IdentifierHash >	getAllCurrentHashes () const override
virtual size_t	numberOfCollections () const override
virtual void	cleanUp (deleter_f *deleter) noexcept override
virtual size_t	fullSize () const noexcept override
virtual StatusCode	fetchOrCreate (IdentifierHash hashId) override
virtual StatusCode	fetchOrCreate (const std::vector< IdentifierHash > &hashIds) override
virtual bool	insert (IdentifierHash hashId, const void *ptr) override
virtual const void *	findIndexPtr (IdentifierHash hashId) const noexcept override
virtual StatusCode	addLock (IdentifierHash hashId, const void *ptr) override
virtual void *	removeCollection (IdentifierHash hashId) override
virtual void	destructor (deleter_f *) noexcept override

Private Attributes
std::vector< I_InternalIDC::hashPair >	m_map
size_t	m_maximumSize

Detailed Description

Definition at line 18 of file InternalOffline.h.

Member Typedef Documentation

deleter_f

typedef void EventContainers::I_InternalIDC::deleter_f(const void *p)

inherited

Definition at line 14 of file I_InternalIDC.h.

hashPair

typedef EventContainers::hashPair<void> EventContainers::I_InternalIDC::hashPair

inherited

Definition at line 37 of file I_InternalIDC.h.

InternalConstItr

typedef std::vector<hashPair>::const_iterator EventContainers::I_InternalIDC::InternalConstItr

inherited

Definition at line 38 of file I_InternalIDC.h.

Constructor & Destructor Documentation

InternalOffline()

InternalOffline::InternalOffline

(

size_t

max

)

Definition at line 11 of file InternalOffline.cxx.

                                           : m_maximumSize(max) {
  //Check optimization assumptions
  static_assert(std::is_trivially_copyable<hashPair>::value);
  static_assert(std::is_trivially_destructible<hashPair>::value);
  static_assert(std::is_trivially_copyable<IdentifierHash>::value);
  static_assert(std::is_trivially_destructible<IdentifierHash>::value);
}

~InternalOffline()

virtual EventContainers::InternalOffline::~InternalOffline ( )

virtualdefault

Member Function Documentation

addLock()

StatusCode InternalOffline::addLock ( IdentifierHash hashId, const void * ptr )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 90 of file InternalOffline.cxx.

                                                                          {
    bool added = insert(hashId, ptr);
    if (!added) [[unlikely]] {
      throw std::runtime_error("IDC WARNING Deletion shouldn't occur in addLock paradigm");
    }
    return StatusCode::SUCCESS;
}

cbegin()

InternalConstItr InternalOffline::cbegin ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 50 of file InternalOffline.cxx.

                               {
    return m_map.cbegin();
}

cend()

InternalConstItr InternalOffline::cend ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 43 of file InternalOffline.cxx.

                             {
    return m_map.cend();
}

cleanUp()

void InternalOffline::cleanUp ( deleter_f * deleter )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 65 of file InternalOffline.cxx.

                                                         {
    for(const auto& x : m_map)  deleter(x.second);
    m_map.clear();
}

destructor()

void InternalOffline::destructor ( deleter_f * deleter )

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 114 of file InternalOffline.cxx.

                                                            {
    for(const auto& x : m_map)  deleter(x.second);
}

fetchOrCreate() [1/2]

StatusCode InternalOffline::fetchOrCreate ( const std::vector< IdentifierHash > & hashIds )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 109 of file InternalOffline.cxx.

{
    throw std::runtime_error("Not implemented in offline mode");
}

fetchOrCreate() [2/2]

StatusCode InternalOffline::fetchOrCreate ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 106 of file InternalOffline.cxx.

                                                        {
    throw std::runtime_error("Not implemented in offline mode");
}

findIndexPtr()

const void * InternalOffline::findIndexPtr ( IdentifierHash hashId ) const

overridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 84 of file InternalOffline.cxx.

                                                                             {
    auto itr = indexFind(hashId);
    if(itr != m_map.end()) return itr->second;
    return nullptr;
}

fullSize()

virtual size_t EventContainers::InternalOffline::fullSize ( ) const

inlineoverridevirtualnoexcept

Implements EventContainers::I_InternalIDC.

Definition at line 32 of file InternalOffline.h.

{return m_maximumSize;}

getAllCurrentHashes()

std::vector< IdentifierHash > InternalOffline::getAllCurrentHashes ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 33 of file InternalOffline.cxx.

                                                                     {
    std::vector<IdentifierHash> ids;
    ids.reserve(m_map.size());
    for(auto &x : m_map) {
        ids.emplace_back(x.first);
    }
    return ids;
}

getAllHashPtrPair()

const std::vector< I_InternalIDC::hashPair > & InternalOffline::getAllHashPtrPair ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 47 of file InternalOffline.cxx.

{ return m_map; }

indexFind()

InternalConstItr InternalOffline::indexFind ( IdentifierHash hashId ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 54 of file InternalOffline.cxx.

                                                                        {
   auto itr = std::lower_bound( m_map.cbegin(), m_map.cend(), hashId.value(), [](const hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
   if(itr!= m_map.cend() && itr->first==hashId) return itr;
   return m_map.cend();
//  return std::find_if(m_map.begin(), m_map.end(), [hashId](const hashPair &lhs) -> bool { return lhs.first == hashId; });
}

insert()

bool InternalOffline::insert ( IdentifierHash hashId, const void * ptr )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 70 of file InternalOffline.cxx.

                                                                   {
    if(m_map.empty() || m_map.back().first < hashId){
        m_map.emplace_back(hashId, ptr);
        return true;
    }
    auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](const hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
    if(itr == std::end(m_map) || itr->first != hashId)
    {
        m_map.emplace(itr, hashId, ptr);
        return true;
    }
    return false;
}

numberOfCollections()

size_t InternalOffline::numberOfCollections ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 61 of file InternalOffline.cxx.

                                                  {
    return m_map.size();
}

removeCollection()

void * InternalOffline::removeCollection ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 98 of file InternalOffline.cxx.

                                                               {
   auto itr = std::lower_bound( m_map.begin(), m_map.end(), hashId.value(), [](hashPair &lhs,  IdentifierHash::value_type rhs) -> bool { return lhs.first < rhs; } );
   if(itr== m_map.end() || itr->first!=hashId) return nullptr;
   void* ptr = const_cast< void* > (itr->second);
   m_map.erase(itr);
   return ptr;
}

tryAddFromCache() [1/2]

bool InternalOffline::tryAddFromCache ( IdentifierHash hashId )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 24 of file InternalOffline.cxx.

{
    return indexFind(hash) != m_map.cend();//No Cache in offline mode
}

tryAddFromCache() [2/2]

bool InternalOffline::tryAddFromCache ( IdentifierHash hashId, EventContainers::IDC_WriteHandleBase & lock )

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 20 of file InternalOffline.cxx.

                                                                                              {
    return indexFind(hash) != m_map.cend();//No Cache in offline mode
}

wait()

void InternalOffline::wait ( ) const

overridevirtual

Implements EventContainers::I_InternalIDC.

Definition at line 29 of file InternalOffline.cxx.

                                 {
    //No need to wait in offline, deliberately empty method
}

Member Data Documentation

m_map

std::vector<I_InternalIDC::hashPair> EventContainers::InternalOffline::m_map

private

Definition at line 41 of file InternalOffline.h.

m_maximumSize

size_t EventContainers::InternalOffline::m_maximumSize

private

Definition at line 42 of file InternalOffline.h.

---

The documentation for this class was generated from the following files:

• InternalOffline.h
• InternalOffline.cxx