Control/CxxUtils/CxxUtils/Array.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-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
#ifndef CXXUTILS_ARRAY_H
#define CXXUTILS_ARRAY_H
 
 
#include "CxxUtils/Arrayrep.h"
#include <iterator>
 
 
namespace CxxUtils {
 
 
// Forward declarations.
template <unsigned int N>
class ArrayIterator;
template <unsigned int N>
class WritableArray;
 
 
//**********************************************************************
 

template <unsigned int N>
class ArrayIteratorChooser
{
public:
  typedef ArrayIterator<N> const_iterator;
 

  static const_iterator make_iterator (const Arrayrep* rep, unsigned int offs);
};
 

template <>
class ArrayIteratorChooser<1>
{
public:
  typedef const Arrayelt* const_iterator;
 

  static const_iterator make_iterator (const Arrayrep* rep, unsigned int offs);
};
 
 
//**********************************************************************
 

template <unsigned int N>
class Array
{
public:
  enum { NDIM = N };

  typedef typename ArrayIteratorChooser<N>::const_iterator const_iterator;
 

  Array ();

  Array (const Arrayrep& rep);

  bool valid() const;

  std::vector<unsigned int> shape() const;

  unsigned int size (unsigned int dim = 0) const;

  Array<N-1> operator[] (unsigned int i) const;

  const Arrayelt* ptr () const;
 

  const_iterator begin () const;
 

  const_iterator end   () const;
 

  void write_array (std::ostream& stream) const;
 
 
  // Protected, not private, so that they can be accessed by @c WritableArray.
protected:
  Array (const Arrayrep& rep, unsigned int offs);
 
  // These classes need to call the above protected constructor.
  friend class Array<N+1>;
  friend WritableArray<N+1>;
  friend class ArrayIterator<N+1>;

  const Arrayrep* m_rep;

  unsigned int m_offs;
};
 

template <>
class Array<0>
{
public:
  enum { NDIM = 0 };

  Array ();

  Array (const Arrayrep& rep);

  bool valid() const;

  std::vector<unsigned int> shape() const;

  unsigned int size (unsigned int dim=0) const;

  operator Arrayelt() const;

  int asint () const;
 

  void write_array (std::ostream& stream) const;
 
 
  // Protected, not private, so that they can be accessed by @c WritableArray.
protected:
  Array (const Arrayrep& rep, unsigned int offs);
 
  // This class needs to call the above protected constructor.
  friend class Array<1>;
  friend class WritableArray<1>;

  const Arrayelt* m_elt;
};
 
 
template <unsigned int N>
std::ostream& operator<< (std::ostream& s, const Array<N>& a);
 
 
//**********************************************************************
 

template <unsigned int N>
class ArrayIterator
{
public:
  using iterator_category = std::random_access_iterator_tag;
  using value_type = const Array<N-1>;
  using difference_type = std::ptrdiff_t;
  using reference = value_type&;
 

  class pointer
  {
  public:
    pointer (const ArrayIterator& i);
 

    value_type operator* () const;
 

    const value_type* operator-> () const;
 
 
  private:
    value_type m_a;
  };
 

  ArrayIterator ();
 

  ArrayIterator (const Arrayrep* rep, unsigned int offs);
 
  // Use default copy ctor and assignment.

  bool operator== (const ArrayIterator& other) const;
 

  bool operator!= (const ArrayIterator& other) const;
 

  bool operator<  (const ArrayIterator& other) const;
 

  bool operator>  (const ArrayIterator& other) const;
 

  bool operator<= (const ArrayIterator& other) const;
 

  bool operator>= (const ArrayIterator& other) const;
 

  value_type operator* () const;
 

  pointer operator-> () const;
 

  ArrayIterator<N>& operator++ ();
 

  ArrayIterator<N>  operator++ (int);
 

  ArrayIterator<N>& operator-- ();
 

  ArrayIterator<N>  operator-- (int);
 

  value_type operator[] (difference_type n) const;
 

  ArrayIterator<N>& operator+= (difference_type n);
 

  ArrayIterator<N>  operator+  (difference_type n) const;
 

  ArrayIterator<N>& operator-= (difference_type n);
 

  ArrayIterator<N>  operator-  (difference_type n) const;
 

  difference_type    operator- (const ArrayIterator& other) const;
 
 
private:
  const Arrayrep* m_rep;

  unsigned int m_offs;
};
 
 
//**********************************************************************
 

template <unsigned int N>
class WritableArray
  : public Array<N>
{
public:
  WritableArray (Arrayrep& rep);

  WritableArray<N-1> operator[] (unsigned int i);

  Array<N-1> operator[] (unsigned int i) const;

  Arrayelt* ptr ();
 
 
private:
  WritableArray (Arrayrep& rep, unsigned int offs);
 
  // This class needs to call the above protected constructor.
  friend class WritableArray<N+1>;

  Arrayrep* m_rep_nc;
};
 

template <>
class WritableArray<0>
  : public Array<0>
{
public:
  WritableArray (Arrayrep& rep);

  WritableArray<0>& operator= (Arrayelt elt);
 
 
private:
  WritableArray (Arrayrep& rep, unsigned int offs);
 
  // This class needs to call the above protected constructor.
  friend class WritableArray<1>;

  Arrayelt* m_elt_nc;
};
 
 
//**********************************************************************
 

template <unsigned int N>
class WritableArrayData
  : private Arrayrep,
    public WritableArray<N>
{
public:
  WritableArrayData (const unsigned int shape[]);

  WritableArrayData (const std::vector<unsigned int>& shape);
};
 

template <class T>
  requires std::assignable_from<T&, float>
void fromArrayrep (const CaloRec::Arrayrep& rep, T& x);
 

template <unsigned int N>
void fromArrayrep (const CaloRec::Arrayrep& rep, CxxUtils::Array<N>& x);
 

template <class T>
concept FromArrayrep =
  requires (T t, const CxxUtils::Arrayrep& rep)
  {
    { CxxUtils::fromArrayrep (rep, t) };
  };
 
 
} // namespace CxxUtils
 
 
#include "CxxUtils/Array.icc"
 
 
// Backwards compatibility.
namespace CaloRec {
  using CxxUtils::Array;
  using CxxUtils::WritableArray;
  using CxxUtils::WritableArrayData;
}
 
 
#endif // not CXXUTILS_ARRAY_H