00001
00002
00003 #ifndef __SOURCE_H__
00004 #define __SOURCE_H__
00005
00006 #include "Point.h"
00007 #include "Point2D.h"
00008 #include "Point3D.h"
00009 #include "libBaseTypes.h"
00010 #include "Registry.h"
00011 #include "libRefCount.h"
00012
00013 #undef DEBUG
00014 #define DEBUG 0
00015 #include "libDebug.h"
00016
00017 typedef RegistryOf<Parameter*> RegistryOfParameters;
00018
00019 inline void RegisterPointAsParameter(RegistryOfParameters ®, PointOf<2, Real>& pt)
00020 {
00021 reg.Register(&pt.X());
00022 reg.Register(&pt.Y());
00023 }
00024
00025 inline void RegisterPointAsParameter(RegistryOfParameters ®, PointOf<3, Real>& pt)
00026 {
00027 reg.Register(&pt.X());
00028 reg.Register(&pt.Y());
00029 reg.Register(&pt.Z());
00030 }
00031
00032
00033 class BasicSource: public Counted
00034 {
00035 public:
00036 BasicSource(const BasicSource& bs) :
00037 Counted(bs)
00038 {
00039 }
00040
00041 BasicSource() :
00042 Counted()
00043 {
00044 }
00045
00046 virtual ~BasicSource() __attribute__((always_inline))
00047 {
00048 }
00049
00050 virtual String Describe() const =0;
00051
00052 virtual void Serialize(Stream& st) const=0;
00053 virtual void Deserialize(Stream &st)=0;
00054 };
00055
00056 #include "libSerialize.h"
00057
00058 template<class DATA, int DIMENSIONALITY, class PRECISION>
00059 class SourceBaseOf: public BasicSource
00060 {
00061 typedef PointOf<DIMENSIONALITY, PRECISION> POINT;
00062
00063 public:
00064 typedef PRECISION type_precision;
00065 typedef DATA type_data;
00066 static const int type_dimensionality = DIMENSIONALITY;
00067 typedef PointOf<DIMENSIONALITY, PRECISION> type_point;
00068
00069 template<class T>
00070 static PRECISION cast_precision(const T&t)
00071 {
00072 return PRECISION(t);
00073 }
00074
00075 virtual ~SourceBaseOf() __attribute__((always_inline))
00076 {
00077 }
00078
00079 virtual String DescribeCommon() const
00080 {
00081 return _INDENT + (_LINE + "size: " + this->Size().Describe() + LINE_);
00082 }
00083
00084 virtual const POINT& Size() const=0;
00085
00086 virtual void VirtualGetPoint(DATA& dataOut, const POINT& pt) const =0;
00087 virtual void VirtualSetPoint(const POINT& pt, const DATA& data)=0;
00088
00089 virtual POINT Bound(const POINT& pt) const=0;
00090
00091 virtual void RegisterDataAsParameters(RegistryOfParameters& reg) =0;
00092
00093 virtual void PrepareForAccess() const
00094 {
00095 }
00096
00097 PRECISION CSize() const
00098 {
00099 return Size().CVolume();
00100 }
00101
00102 PRECISION CSize(int n) const
00103 {
00104 return Size().Dim(n);
00105 }
00106 };
00107
00108 template<class DATA, int DIMENSIONALITY, class PRECISION>
00109 class SourceOf: public SourceBaseOf<DATA, DIMENSIONALITY, PRECISION>
00110 {
00111 };
00112
00113 template<class DATA, class PRECISION>
00114 class SourceOf<DATA, 2, PRECISION> : public SourceBaseOf<DATA, 2, PRECISION>
00115 {
00116 static const int DIMENSIONALITY = 2;
00117 typedef PointOf<DIMENSIONALITY, PRECISION> POINT;
00118 public:
00119 virtual ~SourceOf() __attribute__((always_inline))
00120 {
00121 }
00122
00123 virtual void
00124 VirtualGet(DATA& dataOut, const PRECISION& nX, const PRECISION& nY) const =0;
00125 virtual void
00126 VirtualSet(const PRECISION& nX, const PRECISION& nY, const DATA& data)=0;
00127 };
00128
00129 template<class DATA, class PRECISION>
00130 class SourceOf<DATA, 3, PRECISION> : public SourceBaseOf<DATA, 3, PRECISION>
00131 {
00132 static const int DIMENSIONALITY = 3;
00133 typedef PointOf<DIMENSIONALITY, PRECISION> POINT;
00134 public:
00135
00136 virtual ~SourceOf() __attribute__((always_inline))
00137 {
00138 }
00139
00140 virtual void
00141 VirtualGet(DATA& dataOut, const PRECISION& nX, const PRECISION& nY, const PRECISION& nZ) const =0;
00142 virtual void
00143 VirtualSet(const PRECISION& nX, const PRECISION& nY, const PRECISION& nZ, const DATA& data)=0;
00144
00145 };
00146
00147 template<class SOURCE, class DATA, int DIMENSIONALITY, class PRECISION>
00148 inline void GetPoint(const SOURCE& src, DATA& dataOut, const PointOf<
00149 DIMENSIONALITY, PRECISION>& pt)
00150 {
00151 src.GetPoint(dataOut, pt);
00152 }
00153
00154 template<class DATA, int DIMENSIONALITY, class PRECISION, class PRECISION2>
00155 inline void GetPoint(const SourceOf<DATA, DIMENSIONALITY, PRECISION>& src, DATA& dataOut, const PointOf<
00156 DIMENSIONALITY, PRECISION2>& pt)
00157 {
00158 src.VirtualGetPoint(dataOut, pt);
00159 }
00160
00161 template<class SOURCE, class DATA, int DIMENSIONALITY, class PRECISION>
00162 inline void SetPoint(SOURCE& src, const PointOf<DIMENSIONALITY, PRECISION>& pt, const DATA& data)
00163 {
00164 src.SetPoint(pt, data);
00165 }
00166
00167 template<class DATA, int DIMENSIONALITY, class PRECISION, class PRECISION2>
00168 inline void SetPoint(SourceOf<DATA, DIMENSIONALITY, PRECISION>& src, const PointOf<
00169 DIMENSIONALITY, PRECISION2>& pt, const DATA& data)
00170 {
00171 src.VirtualSetPoint(pt, data);
00172 }
00173
00174 #define TESTERROR(x)
00175
00176 #define SOURCE_ACTUALS_2D \
00177 static const int DIMENSIONALITY=2; \
00178 typedef PointOf<DIMENSIONALITY,PRECISION> type_point; \
00179 typedef DATA type_data; \
00180 typedef PRECISION type_precision; \
00181 static const int type_dimensionality=DIMENSIONALITY; \
00182 \
00183 inline void GetPoint(DATA& dataOut, const PointOf<2,PRECISION>& pt) const \
00184 { \
00185 this->Get(dataOut,pt.X(),pt.Y()); \
00186 } \
00187 \
00188 inline void VirtualGetPoint(DATA& dataOut, const PointOf<2,PRECISION>& pt) const \
00189 { \
00190 TESTERROR("called VirtualGetPoint"); \
00191 this->Get(dataOut,pt.X(),pt.Y()); \
00192 } \
00193 \
00194 inline void SetPoint(const PointOf<2,PRECISION>& pt, const DATA& data) \
00195 { \
00196 this->Set(pt.X(),pt.Y(),data); \
00197 } \
00198 \
00199 inline void VirtualSetPoint(const PointOf<2,PRECISION>& pt, const DATA& data) \
00200 { \
00201 TESTERROR("called VirtualSetPoint"); \
00202 this->Set(pt.X(),pt.Y(),data); \
00203 } \
00204 \
00205 inline void VirtualGet(DATA& dataOut, const PRECISION& rX, const PRECISION& rY) const \
00206 { \
00207 TESTERROR("called VirtualGet"); \
00208 Get(dataOut,rX,rY); \
00209 this->Get(dataOut,rX,rY); \
00210 } \
00211 \
00212 inline void VirtualSet(const PRECISION &rX, const PRECISION &rY, const DATA& data) \
00213 { \
00214 TESTERROR("called VirtualSet"); \
00215 this->Set(rX,rY,data); \
00216 }
00217
00218 template<class SOURCE, class DATA, class PRECISION>
00219 inline void Get(const SOURCE& src, DATA& dataOut, const PRECISION& nX, const PRECISION& nY)
00220 {
00221 src.Get(dataOut, nX, nY);
00222 }
00223 template<class DATA, class PRECISION, class PRECISION2>
00224 inline void Get(const SourceOf<DATA, 2, PRECISION>& src, DATA& dataOut, const PRECISION2& nX, const PRECISION2& nY)
00225 {
00226 src.VirtualGet(dataOut, src.cast_precision(nX), src.cast_precision(nY));
00227 }
00228
00229 template<class SOURCE, class DATA, class PRECISION>
00230 inline void Set(SOURCE& src, const PRECISION& nX, const PRECISION& nY, const DATA& data)
00231 {
00232 src.Set(nX, nY, data);
00233 }
00234
00235 template<class DATA, class PRECISION, class PRECISION2>
00236 inline void Set(SourceOf<DATA, 2, PRECISION>& src, const PRECISION2& nX, const PRECISION2& nY, const DATA& data)
00237 {
00238 src.VirtualSet(src.cast_precision(nX), src.cast_precision(nY), data);
00239 }
00240
00241 #define SOURCE_ACTUALS_3D \
00242 static const int DIMENSIONALITY=3; \
00243 typedef PointOf<DIMENSIONALITY,PRECISION> type_point; \
00244 typedef DATA type_data; \
00245 typedef PRECISION type_precision; \
00246 static const int type_dimensionality=DIMENSIONALITY; \
00247 \
00248 inline void GetPoint(DATA& dataOut, const PointOf<3,PRECISION>& pt) const \
00249 { \
00250 this->Get(dataOut,pt.X(),pt.Y(),pt.Z()); \
00251 } \
00252 \
00253 inline void VirtualGetPoint(DATA& dataOut, const PointOf<3,PRECISION>& pt) const \
00254 { \
00255 TESTERROR("called VirtualGetPoint"); \
00256 this->Get(dataOut,pt.X(),pt.Y(),pt.Z()); \
00257 } \
00258 \
00259 inline void SetPoint(const PointOf<3,PRECISION>& pt, const DATA& data) \
00260 { \
00261 this->Set(pt.X(),pt.Y(),pt.Z(),data); \
00262 } \
00263 \
00264 inline void VirtualSetPoint(const PointOf<3,PRECISION>& pt, const DATA& data) \
00265 { \
00266 TESTERROR("called VirtualSetPoint"); \
00267 this->Set(pt.X(),pt.Y(),pt.Z(),data); \
00268 } \
00269 \
00270 inline void VirtualGet(DATA& dataOut, const PRECISION& rX, const PRECISION& rY, const PRECISION& rZ) const \
00271 { \
00272 TESTERROR("called VirtualGet"); \
00273 this->Get(dataOut,rX,rY,rZ); \
00274 } \
00275 \
00276 inline void VirtualSet(const PRECISION &rX, const PRECISION &rY, const PRECISION& rZ, const DATA& data) \
00277 { \
00278 TESTERROR("called VirtualSet"); \
00279 this->Set(rX,rY,rZ,data); \
00280 }
00281
00282 template<class SOURCE, class DATA, class PRECISION>
00283 inline void Get(const SOURCE& src, DATA& dataOut, const PRECISION& nX, const PRECISION& nY, const PRECISION& nZ)
00284 {
00285 src.Get(dataOut, nX, nY, nZ);
00286 }
00287
00288 template<class DATA, class PRECISION, class PRECISION2>
00289 inline void Get(const SourceOf<DATA, 3, PRECISION>& src, DATA& dataOut, const PRECISION2& nX, const PRECISION2& nY, const PRECISION2& nZ)
00290 {
00291 src.VirtualGet(dataOut, src.cast_precision(nX), src.cast_precision(nY),
00292 src.cast_precision(nZ));
00293 }
00294
00295 template<class SOURCE, class DATA, class PRECISION>
00296 inline void Set(SOURCE& src, const PRECISION& nX, const PRECISION& nY, const PRECISION& nZ, const DATA& data)
00297 {
00298 src.Set(nX, nY, nZ, data);
00299 }
00300
00301 template<class DATA, class PRECISION, class PRECISION2>
00302 inline void Set(SourceOf<DATA, 3, PRECISION>& src, const PRECISION2& nX, const PRECISION2& nY, const PRECISION2& nZ, const DATA& data)
00303 {
00304 src.VirtualSet(src.cast_precision(nX), src.cast_precision(nY),
00305 src.cast_precision(nZ), data);
00306 }
00307
00308 #define TypeOfSource(x) typename x::type_source
00309 #define TypeOfPrecision(x) typename x::type_precision
00310 #define TypeOfData(x) typename x::type_data
00311 #define TypeOfDimensionality(x) x::type_dimensionality
00312 #define TypeOfPoint(x) typename x::type_point
00313
00314 #endif // __SOURCE_H__
