/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/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++ -*-.
// $Id: Array.h,v 1.2 2009-04-07 04:26:22 ssnyder Exp $
#ifndef CXXUTILS_ARRAY_H
#define CXXUTILS_ARRAY_H


#include "CxxUtils/Arrayrep.h"
#include <iterator>


namespace CxxUtils {


// Forward declaration.
template <unsigned int N>
class ArrayIterator;


//**********************************************************************


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;


  // 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 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;


  // 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>;

  const Arrayelt* m_elt;
};


//**********************************************************************


template <unsigned int N>
class ArrayIterator
  : public std::iterator<std::random_access_iterator_tag, const Array<N-1> >
{
public:
  // Typedefs.
  typedef std::iterator<std::random_access_iterator_tag, const Array<N-1> >
             base_iterator;

  typedef typename base_iterator::iterator_category iterator_category;

  typedef typename base_iterator::value_type        value_type;

  typedef typename base_iterator::difference_type   difference_type;

  typedef typename base_iterator::reference         reference;


  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) const;

  Arrayelt* ptr ();


private:
  WritableArray (Arrayrep& rep, unsigned int offs);

  // This class needs to call the above protected constructor.
  friend class WritableArray<N+1>;
};


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>;
};


//**********************************************************************


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

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


} // namespace CxxUtils


#include "CxxUtils/Array.icc"


// Backwards compatibility.
namespace CaloRec {
  using CxxUtils::Array;
  using CxxUtils::WritableArray;
  using CxxUtils::WritableArrayData;
}


#endif // not CXXUTILS_ARRAY_H

---