array_dec.h 5.99 KB
Newer Older
1
2
3
4
5
/*! \file array_dec.h
 * \brief array class declarations (prototypes)
 * 
 * ----------------------------------------------------------------------------
 * 
6
 * $Id: array_dec.h,v 1.2 2002-12-08 22:33:53 forbrig Exp $
7
 * \author Thomas Forbriger
8
 * \since 08/12/2002
9
10
 * 
 * array class declarations (prototypes)
11
12
13
14
15
16
 *
 * \note
 * This should never be included directly. Use array.h or binarray.h instead.
 *
 * \todo 
 * Do we need the using directive?
17
18
19
20
 * 
 * Copyright (c) 2002 by Thomas Forbriger (IMG Frankfurt) 
 * 
 * REVISIONS and CHANGES 
21
 *  - 08/12/2002   V1.0   copied from libcontxx
22
23
24
25
26
 * 
 * ============================================================================
 */

// include guard
27
#ifndef AFF_ARRAY_DEC_H_VERSION
28

29
30
31
32
#define AFF_ARRAY_DEC_H_VERSION \
  "AFF_ARRAY_DEC_H   V1.0   "
#define AFF_ARRAY_DEC_H_CVSID \
  "$Id: array_dec.h,v 1.2 2002-12-08 22:33:53 forbrig Exp $"
33

34
35
36
#include <aff/sharedheap.h>
#include <aff/strided.h>
#include <aff/range.h>
37

38
namespace aff {
39

40
#ifdef AFF_PREBUILT
41
42
43
44
namespace prebuilt {
#endif

#ifdef CONTXX_PREBUILT
45
46
47
48
  using namespace aff::prebuilt::util;
  using namespace aff::prebuilt::shape;
  using  aff::prebuilt::representation::SharedHeap;
  using  aff::prebuilt::subscriptor::StridedRepresentation;
49
#else
50
51
52
53
  using namespace aff::util;
  using namespace aff::shape;
  using  aff::representation::SharedHeap;
  using  aff::subscriptor::StridedRepresentation;
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
#endif

  /*! \brief Full multi-dimensional array functionality.
   *
   * The array class highly depends on base classes from which inherts most of
   * its functionality. 
   * The user may select from several provided array designs through template
   * parameters:
   * \param T element type of array (passed to Subscriptor base class)
   * \param N dimensionality of array (passed to Subscriptor base class)
   * \param Representation Representation (engine for memory access) base
   *        class type (passed to Subscriptor base class)
   * \param Subscriptor Subscriptor base class type
   *
   * \sa \ref page_shapes_and_subscriptors
   * \sa \ref page_representation
   * \sa \ref sec_main_modules
   * \sa tests/arraytest.cc
72
73
74
75
76
77
78
79
80
   *
   * \todo
   * documentation of class Array must be reworked
   *
   * \todo
   * class Array must be reworked itself entirely
   *
   * \todo 
   * Explain the new concept of multidimensional array indexing
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
   */
  template<class T,
           Tdim N=1,
           template<class TT> 
             class Representation=SharedHeap,
           template<class TT, Tdim NN, template<class TTT> class RR> 
             class Subscriptor=StridedRepresentation>
    class Array:
      public Subscriptor<T, N, Representation>
    {
        public:
          //! Type of representation
          typedef Representation<T> Trepresentation;
          //! Type of subscriptor
          typedef Subscriptor<T, N, Representation> Tsubscriptor;
          //! Type of shape
          typedef typename Tsubscriptor::Tshape Tshape;
          //! Element type
          typedef typename Trepresentation::Tvalue Tvalue;
          //! Type of pointer to element
          typedef typename Trepresentation::Tpointer Tpointer;
          //! Type of reference to element
          typedef typename Trepresentation::Treference Treference;
          //! Type of const reference to element
          typedef typename Trepresentation::Tconst_reference Tconst_reference;
          //! Type to be used as data representation
          typedef typename Trepresentation::Tmutable_value Tmutable_value;
          //! Type to be used as element for const version
          typedef typename Trepresentation::Tconst_value Tconst_value;
          //! Type of this array
          typedef Array<T, N, Representation, Subscriptor> Tcontainer;
          //! Type of the array of const values
          typedef Array<Tconst_value, N, Representation, Subscriptor>
              Tcontainer_of_const;
          /*! \brief \b deprecated! Type of size array
           * \deprecated
           * This feature may be removed in future versions
           */
          typedef SimpleRigidArray<Tsize, N> Tsizes;
          /*! \brief \b deprecated! Type of range 
           * \deprecated
           * This feature may be removed in future versions
           */
          typedef Range<Tsubscript> Trange;
          /*! \brief \b deprecated! Type of range array
           * \deprecated
           * This feature may be removed in future versions
           */
          typedef SimpleRigidArray<Trange, N> Tranges;

          //! construct from nothing (empty)
          Array() { }
          //! construct from shape and representation
          Array(const Tshape& shape, 
                const Trepresentation& representation);
          //! construct from shape
          explicit Array(const Tshape& shape);
          /*! \brief \b deprecated! construct from sizes
           * \deprecated
           * This constructor may be removed in future versions
           * Use shapers instead.
           */
          explicit Array(const Tsizes& size);
          /*! \brief \b deprecated! construct from ranges
           * \deprecated
           * This constructor may be removed in future versions.
           * Use shapers instead.
           */
          explicit Array(const Tranges& ranges);

          //! conversion to container of const values
          operator Tcontainer_of_const() const
          {
            Tcontainer_of_const retval(*this, *this);
            return(retval);
          }

          //! by size we mean the size defined by the shape
          Tsize size(const Tsubscript& i) const
          { return(this->Tshape::size(i)); }
          //! by size we mean the size defined by the shape
          Tsize size() const
          { return(this->Tshape::size()); }
            
          //! set value to whole array
          Array& operator=(const T& value);

    }; // class Array

170
171
#ifdef AFF_PREBUILT
} // namespace prebuilt
172
173
#endif

174
} // namespace aff
175

176
177
#ifndef AFF_NO_DEFINITIONS
#include <aff/array_def.h>
178
179
#endif

180
#endif // AFF_ARRAY_DEC_H_VERSION (includeguard)
181
182

/* ----- END OF array_dec.h ----- */