array_dec.h 5.12 KB
Newer Older
1
2
3
4
5
/*! \file array_dec.h
 * \brief array class declarations (prototypes)
 * 
 * ----------------------------------------------------------------------------
 * 
thomas.forbriger's avatar
thomas.forbriger committed
6
 * $Id: array_dec.h,v 1.3 2002-12-10 19:56:01 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
#define AFF_ARRAY_DEC_H_VERSION \
  "AFF_ARRAY_DEC_H   V1.0   "
#define AFF_ARRAY_DEC_H_CVSID \
thomas.forbriger's avatar
thomas.forbriger committed
32
  "$Id: array_dec.h,v 1.3 2002-12-10 19:56:01 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
   *
thomas.forbriger's avatar
thomas.forbriger committed
73
74
75
76
77
78
79
80
   * \note
   * We may just use the default copy constructor and default copy operator.
   *
   * If you want to create an array for externally managed memory (e.g. arrays
   * taken from Fortran code): First create a SharedHeap representation for the
   * given memory pointer and size. Second create a shape, defining the memory
   * layout and then create the array object from these both.
   *
81
82
83
84
85
86
87
88
   * \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
89
   */
thomas.forbriger's avatar
thomas.forbriger committed
90
  template<class T>
91
    class Array:
thomas.forbriger's avatar
thomas.forbriger committed
92
      public aff::Strided, public aff::SharedHeap<T>
93
    {
thomas.forbriger's avatar
thomas.forbriger committed
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
      public:
        //! Type of representation
        typedef aff::SharedHeap<T> Trepresentation;
        //! Type of subscriptor
        typedef aff::Strided 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> Tcontainer;
        //! Type of the array of const values
        typedef Array<Tconst_value> Tcontainer_of_const;

        //! construct from nothing (empty)
        Array() { }
        //! construct from shape and representation
        Array(const Tshape& shape, 
              const Trepresentation& representation);
        //! construct from shape (defines size and layout)
        explicit Array(const Tshape& shape);

        //! 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 whole array to value
        Array& operator=(const T& value);

        //! create an identical COPY (deep copy) of this array
        Array copyout() const;

        //! COPY values (deep copy) from other array of convertible type
        //! (returns itself)
        template<class TT>
          Array& copyin(const Array<TT>& a);
148
149
150

    }; // class Array

151
152
#ifdef AFF_PREBUILT
} // namespace prebuilt
153
154
#endif

155
} // namespace aff
156

157
158
#ifndef AFF_NO_DEFINITIONS
#include <aff/array_def.h>
159
160
#endif

161
#endif // AFF_ARRAY_DEC_H_VERSION (includeguard)
162
163

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