ForwardIndexingPolicy.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/**
 * @file AthLinks/tools/ForwardIndexingPolicy.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Dec, 2013
 * @brief Indexing policy for a vector-like container.
 */
 
 
namespace SG {
 
 
/**
 * @brief Test to see if an index is valid.
 * @param index The index to test.
 */
template <class CONT, class VALUE_TYPE>
inline
bool ForwardIndexingPolicy<CONT, VALUE_TYPE>::isValid (stored_index_type index)
{
  return index != static_cast<stored_index_type>(INVALID);
}
 
 
/**
 * @brief Convert from stored to external index types.
 * @param index The stored index.
 */
template <class CONT, class VALUE_TYPE>
inline
typename ForwardIndexingPolicy<CONT, VALUE_TYPE>::index_type
ForwardIndexingPolicy<CONT, VALUE_TYPE>::storedToExternal (stored_index_type index)
{
  if (index == static_cast<stored_index_type>(INVALID))
    return INVALID;
  return index;
}
 
 
/**
 * @brief Make an index invalid.
 * @param index[out] The index to reset.
 */
template <class CONT, class VALUE_TYPE>
inline
void ForwardIndexingPolicy<CONT, VALUE_TYPE>::reset (stored_index_type& index)
{
  index = static_cast<stored_index_type>(INVALID);
}
 
 
/**
 * @brief Retrieve from a container the element corresponding to an index.
 * @param index The index to fetch.
 * @param data The container.
 *
 * Will throw SG::ExcBadForwardLink if the index is invalid.
 */
template <class CONT, class VALUE_TYPE>
inline
typename ForwardIndexingPolicy<CONT, VALUE_TYPE>::ElementType
ForwardIndexingPolicy<CONT, VALUE_TYPE>::lookup (index_type index, const CONT& data)
{ 
  if (!isValid(index) || (data.size() <= index)) {
    SG::throwExcBadForwardLink (index, data.size(), ClassName<CONT>::name());
  }
 
  typedef typename CONT::const_iterator const_iterator;
  const_iterator iter = data.begin();
  std::advance(iter, index);
  return *iter;
}
 
 
/**
 * @brief Find the index of the (first) instance of ELEMENT in DATA.
 * @param data The container to search.
 * @param element The element to find.
 * @param index[out] The index in the container of @c element.
 *
 * Throws SG::ExcElementNotFound if the element is not in the container.
 */
template <class CONT, class VALUE_TYPE>
void ForwardIndexingPolicy<CONT, VALUE_TYPE>::reverseLookup(const CONT& data,
                                                            ElementConstReference element,
                                                            index_type& index)
{
  // compiler checks we can compare elements
  static_assert (std::equality_comparable<ElementType>);
 
  // Note that reverse lookup redoes the lookup even if m_isValid is true.
  // Must ensure that we get correct index before persistency
  index = INVALID;
  typename CONT::size_type cindex;
  if (!SG::findInContainer (data, element, cindex))
    throwExcElementNotFound ("reverseLookup");
  index = cindex;
}
 
 
} // namespace SG