SGIterator.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
/*
 */
 
 
#include "StoreGate/SGIterator.h"
 

SG::detail::IteratorBase::IteratorBase (SG::ConstProxyIterator itr,
                                        SG::ConstProxyIterator itrEnd,
                                        bool isConst)
{
  setState (itr, itrEnd, isConst).ignore();
}
 

SG::detail::IteratorBase::IteratorBase (const IteratorBase& other)
  : m_proxies (other.m_proxies)
{
  // Maintain shared ownership of elements in our range.
  this->addRef();
}
 

SG::detail::IteratorBase::~IteratorBase()
{
  // Release ownership of everything in our range.
  this->release();
}
 

SG::detail::IteratorBase&
SG::detail::IteratorBase::operator= (const IteratorBase& other)
{
  if (this != &other) {
    // Assign, maintaining refcounts.
    this->release();
    m_proxies = other.m_proxies;
    this->addRef();
  }
  return *this;
}
 

StatusCode
SG::detail::IteratorBase::setState (SG::ConstProxyIterator itr,
                                    SG::ConstProxyIterator itrEnd,
                                    bool isConst)
{
  if (!m_proxies.empty()) {
    this->release();
    m_proxies.clear();
  }
 
  // Save all valid proxies in reverse order.  Also take out a refcount on each.
  while (itr != itrEnd) {
    --itrEnd;
    DataProxy* dp = itrEnd->second;
    if (dp->isValid() && (isConst || !dp->isConst())) {
      m_proxies.push_back (dp);
      dp->addRef();
    }
  }
 
  if (m_proxies.empty()) {
    return StatusCode::FAILURE;
  }
 
  return StatusCode::SUCCESS;
}
 

void SG::detail::IteratorBase::increment()
{
  if (!m_proxies.empty()) {
    m_proxies.back()->release();
    m_proxies.pop_back();
  }
}
 

void SG::detail::IteratorBase::const_check() const
{
  // This should usually not be needed, since we check for constness
  // when initializing the iterator.  However, it is possible for a proxy
  // to be marked as const after the iterator has been formed, so keep the check.
  const SG::DataProxy* dp = this->proxy();
  if (dp->isConst()) {
    const IProxyDict* store = dp->store();
    throw SG::ExcConstObject (dp->clID(),
                              dp->name(),
                              store ? store->name() : "(unknown)");
  }
}
 

const std::string& SG::detail::IteratorBase::key() const
{
  return m_proxies.back()->name();
}