ViewVector.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-2021 CERN for the benefit of the ATLAS collaboration
*/
#ifndef ATHCONTAINERS_VIEWVECTOR_H
#define ATHCONTAINERS_VIEWVECTOR_H
 
 
#include "AthContainers/OwnershipPolicy.h"
#include "AthContainers/IndexTrackingPolicy.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/ViewVectorBase.h"
#include "AthLinks/ElementLink.h"
#include <atomic>
 
 
template <class DV>
class ViewVector
  : public DV, public SG::ViewVectorBase
{
public:
  typedef typename DV::size_type                size_type;
  typedef typename DV::difference_type          difference_type;
  typedef typename DV::allocator_type           allocator_type;
  typedef typename DV::base_value_type          base_value_type;
  typedef typename DV::BaseContainer            BaseContainer;
  typedef typename DV::DVL_BASE                 DVL_BASE;
  typedef typename DV::const_iterator           const_iterator;
  typedef typename DV::const_reverse_iterator   const_reverse_iterator;
  typedef typename DV::value_type               value_type;
  typedef typename DV::const_value_type         const_value_type;
  typedef typename DV::reference                reference;
  typedef typename DV::const_reference          const_reference;
  typedef typename DV::pointer                  pointer;
  typedef typename DV::const_pointer            const_pointer;
  typedef typename DV::unique_type              unique_type;
 
  // cppcheck-suppress duplInheritedMember
  static constexpr bool must_own = DV::must_own;
 
  typedef std::vector<ElementLink<DV> > Pers_t;
 
 
  //========================================================================
 
 
  explicit ViewVector(SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS);
 
 
  explicit ViewVector(size_type n,
                      SG::OwnershipPolicy ownPolicy = SG::VIEW_ELEMENTS);
 
 
  template <class InputIterator>
  ViewVector(InputIterator first, InputIterator last);
 
 
  ViewVector (const ViewVector&) = default;
 
 
  ViewVector (ViewVector&& rhs);
 
 
  ViewVector (const DV& rhs);
 
 
  ViewVector (DV&& rhs);
 
 
  ViewVector(std::initializer_list<value_type> l);
 
 
  ViewVector& operator= (const ViewVector& rhs) = default;
 
 
  ViewVector& operator= (const DV& rhs);
 
 
  ViewVector& operator= (ViewVector&& rhs);
 
 
  ViewVector& operator= (DV&& rhs);
 
 
  ViewVector& operator= (std::initializer_list<value_type> l);
 
 
  using DV::clear;
  
  
  void clear (SG::OwnershipPolicy ownPolicy);
 
 
  void clear (SG::OwnershipPolicy ownPolicy,
              SG::IndexTrackingPolicy trackIndices);
 
 
  virtual void toPersistent() override;
 
 
  virtual void toTransient() override;
 
 
private:
  void registerBaseInit();
};
 
 
#ifndef XAOD_STANDALONE
#include "AthenaKernel/BaseInfo.h"
namespace SG {
 
 
template<class DV>
struct Bases<ViewVector<DV> > {
  using bases = BaseList<DV>;
};                               
 
 
}
#endif
 
 
#include "AthContainers/ViewVector.icc"
 
 
#ifndef XAOD_STANDALONE
 
template <class DV>
struct ClassID_traits< ViewVector<DV> >
{
  static const bool s_isDataObject = false;
  typedef std::integral_constant<bool, s_isDataObject> is_DataObject_tag;
  typedef std::true_type has_classID_tag;
 
  static const CLID& ID() {
    if (s_clid == CLID_NULL)
      SG::throwExcMissingViewVectorCLID (typeid(ViewVector<DV>));
    static const CLID clid = s_clid;
    return clid;
  }
  static const char* typeNameString() {
    if (s_name == nullptr)
      SG::throwExcMissingViewVectorCLID (typeid(ViewVector<DV>));
    return s_name;
  }
  static const std::string& typeName() {
    static const std::string name = typeNameString();  return name;
  }
  static const std::type_info& typeInfo() {
    return typeid (ViewVector<DV>);
  }
  typedef std::false_type has_version_tag;
  static const bool s_isConst = false;
 
  static bool init (CLID clid, const char* name)
  {
    if (s_clid == CLID_NULL) {
      s_clid = clid;
      s_name = name;
    }
    return true;
  }
private:
  static std::atomic<CLID> s_clid;
  static std::atomic<const char*> s_name;
};
 
template <class DV>
std::atomic<CLID> ClassID_traits< ViewVector<DV> >::s_clid { CLID_NULL };
template <class DV>
std::atomic<const char*> ClassID_traits< ViewVector<DV> >::s_name { nullptr };
#endif // not XAOD_STANDALONE
 
 
#ifdef XAOD_STANDALONE
 
// FIXME: xAOD has its own, incompatible, CLASS_DEF, but we don't want to use it
//        due to dependency issues.  Probably need to move things around
//        a bit to resolve this.
#define VIEWVECTOR_CLASS_DEF(NAME, CID)
 
#else
 
#define VIEWVECTOR_CLASS_DEF(NAME, CID) \
  [[maybe_unused]] \
  static const bool clidinit_##CID = ClassID_traits<NAME>::init (CID, #NAME); \
  CLIDREGISTRY_ADDENTRY(CID, NAME)
#endif
 
 
#endif // not ATHCONTAINERS_VIEWVECTOR_H