array_psi.h

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  *
   3  * $Id$
   4  *
   5  ** The MIT License
   6  *
   7  * Copyright (c) 2008 BBC Research
   8  *
   9  * Permission is hereby granted, free of charge, to any person obtaining a copy
  10  * of this software and associated documentation files (the "Software"), to deal
  11  * in the Software without restriction, including without limitation the rights
  12  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  13  * copies of the Software, and to permit persons to whom the Software is
  14  * furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  24  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  25  * THE SOFTWARE.
  26  *
  27  * ***** END LICENSE BLOCK ***** */
  28
  29 #ifndef __ARRAY_H
  30 #define __ARRAY_H
  31
  32 #include <psi.h>
  33
  34 namespace psi
  35 {
  36 /* introduce a new type of dynamic array, that:
  37  *   - performs bound checking on operator[] -- enabled through (1)
  38  *   - disables array convolution to reduce mishtakes -- (2)
  39  */
  40 template<class Target> struct P : MergePolicies
  41         <ArrayDynamicBase
  42         ,ArrayFirstLastSize
  43         ,ArrayAssign
  44         /* ,indexZeroBasedNoCheck */
  45         ,IndexingChecked /* (1) */
  46         ,CheckedArrayAccess
  47         ,ArrayArithmetic
  48         /* ,ArrayConvolution *//* (2) */
  49         ,ArrayIOText
  50         >::Policy<Target>
  51         {
  52         };
  53 }
  54 ;
  55
  56 template<class T> class Array1d : public psi::DynamicArray<T, 1, psi::P> {
  57 public:
  58         const int length() const
  59         {
  60                 return Q::size(1);
  61         }
  62         ;
  63
  64         Array1d(const int length)
  65         {
  66                 typename Q::Params init_params;
  67                 /* setup the inital parameters - ie size. */
  68                 init_params.params(1, psi::Size(length));
  69
  70                 /* tell psi about the actual array size we desire. */
  71                 this->params(init_params);
  72         }
  73         ;
  74
  75 private:
  76         /* TODO? shaddow copy the width,height -- allows for large performance
  77          * increase. */
  78         typedef psi::DynamicArray<T, 1, psi::P> Q;
  79 };
  80
  81 struct Size2d {
  82         int width;
  83         int height;
  84         Size2d(int w, int h) :
  85                 width(w), height(h)
  86         {
  87         }
  88         ;
  89 };
  90
  91 template<class T> class Array2d : public psi::DynamicArray<T, 2, psi::P> {
  92 public:
  93         const int height() const
  94         {
  95                 return Q::size(2);
  96         }
  97         ;
  98         const int width() const
  99         {
 100                 return Q::size(1);
 101         }
 102         ;
 103
 104         Array2d(const int width, const int height)
 105         {
 106                 typename Q::Params init_params;
 107                 /* setup the inital parameters - ie size. */
 108                 init_params.params(1, psi::Size(width));
 109                 init_params.params(2, psi::Size(height));
 110
 111                 /* tell psi about the actual array size we desire. */
 112                 this->params(init_params);
 113         }
 114         ;
 115
 116         Array2d(const Size2d& dim)
 117         {
 118                 typename Q::Params init_params;
 119                 /* setup the inital parameters - ie size. */
 120                 init_params.params(1, psi::Size(dim.width));
 121                 init_params.params(2, psi::Size(dim.height));
 122
 123                 /* tell psi about the actual array size we desire. */
 124                 this->params(init_params);
 125         }
 126         ;
 127
 128 private:
 129         //    Array2d<T>& operator=(const Array2d<T>&);
 130         //    Array2d(const Array2d<T>&);
 131         /* TODO? shaddow copy the width,height -- allows for large performance
 132          * increase. */
 133         typedef psi::DynamicArray<T, 2, psi::P> Q;
 134 };
 135
 136 /* Some magic arrays to get around lack of good references in C++ */
 137 template<class T> class RArray1d {
 138 public:
 139         RArray1d(const int length) :
 140                 data(length)
 141         {
 142         }
 143         ;
 144
 145         /* make read access look like normal container access */
 146         T& operator[](const int i) const
 147         {
 148                 return *(data[i]);
 149         }
 150         ;
 151
 152         /* make write access a bit irritating */
 153         void set(const int i, T& thing)
 154         {
 155                 data[i] = &thing;
 156         }
 157         ;
 158         void set(const int i, T* thing)
 159         {
 160                 data[i] = thing;
 161         }
 162         ;
 163
 164         int length() const
 165         {
 166                 return data.length();
 167         }
 168         ;
 169
 170 private:
 171         /* don't allow copying of this array! */
 172         RArray1d(const RArray1d<T>&);
 173         RArray1d<T>& operator=(const RArray1d<T>&);
 174
 175         Array1d<T*> data;
 176 };
 177
 178 #endif