IAuxTypeVector.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERSINTERFACES_IAUXTYPEVECTOR_H
#define ATHCONTAINERSINTERFACES_IAUXTYPEVECTOR_H
 
 
#include "AthContainersInterfaces/AuxTypes.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainersInterfaces/AuxDataSpan.h"
#include "CxxUtils/CachedValue.h"
#include <cstddef>
#include <memory>
#include <typeinfo>
 
 
namespace SG {
 
 
class AuxDataOption;
 
 
class IAuxTypeVector
{
public:
  IAuxTypeVector (auxid_t auxid, bool isLinked)
    : m_auxid (auxid),
      m_isLinked (isLinked)
  {
  }
 
 
  virtual ~IAuxTypeVector() = default;
 
 
  virtual std::unique_ptr<IAuxTypeVector> clone() const = 0;
 
  
  virtual void* toPtr() = 0;
 
 
  virtual const void* toPtr() const = 0;
 
 
  virtual void* toVector() = 0;
 
 
  virtual size_t size() const = 0;
 
 
  virtual bool resize (size_t sz) = 0;
 
 
  virtual void reserve (size_t sz) = 0;
 
 
  virtual bool shift (size_t pos, ptrdiff_t offs) = 0;
 
 
  virtual bool insertMove (size_t pos,
                           void* src, size_t src_pos, size_t src_n,
                           IAuxStore& srcStore) = 0;
 
 
  virtual bool setOption (const AuxDataOption& /*option*/)
  { return false; }
 
 
  virtual std::unique_ptr<IAuxTypeVector> toPacked() { return 0; }
 
 
  virtual const std::type_info* objType() const { return 0; }
 
 
  virtual std::unique_ptr<IAuxTypeVector> linkedVector() { return nullptr; }
 
 
  bool isLinked() const { return m_isLinked; }
 
 
  auxid_t auxid() const
  {
    return m_auxid;
  }
 
 
  const AuxDataSpanBase& getDataSpan() const
  {
    if (!m_span.isValid()) {
      m_span.set (this->getDataSpanImpl());
    }
    return *m_span.ptr();
  }
 
 
protected:
  virtual AuxDataSpanBase getDataSpanImpl() const = 0;
 
 
  void storeDataSpan (void* beg, size_t size)
  {
    // Only do this if the span is already valid, so that it doesn't
    // get marked valid before ROOT I/O.
    if (m_span.isValid()) {
      m_span.store (AuxDataSpanBase (beg, size));
    }
  }
 
 
  void resetDataSpan()
  {
    m_span.reset();
  }
    
 
private:
  auxid_t m_auxid;
 
  bool m_isLinked;
 
  CxxUtils::CachedValue<AuxDataSpanBase> m_span;
};
 
 
} // namespace SG
 
 
#endif // not ATHCONTAINERSINTERFACES_IAUXTYPEVECTOR_H