00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef MLN_VALUE_PROXY_HH
00027 # define MLN_VALUE_PROXY_HH
00028
00032
00033 # include <mln/core/concept/value.hh>
00034 # include <mln/trait/value_.hh>
00035 # include <mln/metal/unconst.hh>
00036
00037
00038 namespace mln
00039 {
00040
00041
00042 namespace value {
00043 template <typename I> class proxy;
00044 }
00045
00046
00047 namespace trait
00048 {
00049
00050 template <typename I>
00051 struct value_< mln::value::proxy<I> >
00052 :
00053 value_< mln_value(I) >
00054 {
00055 };
00056
00057 template <typename I>
00058 struct value_< mln::value::proxy<const I> >
00059 :
00060 value_< mln_value(I) >
00061 {
00062 };
00063
00064 }
00065
00066
00067 namespace value
00068 {
00069
00074 template <typename I>
00075 class proxy : public Value< proxy<I> >
00076 {
00077 public:
00078
00080 typedef void enc;
00081
00083 typedef mln_value(I) equiv;
00084
00086 proxy(I& ima, const mln_psite(I)& p);
00087
00089 ~proxy();
00090
00092 template <typename V>
00093 proxy<I>& operator=(const V& v);
00094
00096 proxy<I>& operator=(const proxy<I>& rhs);
00097
00099 template <typename II>
00100 proxy<I>& operator=(const proxy<II>& rhs);
00101
00103 template <typename V>
00104 operator V() const;
00105
00107 operator mln_value(I)() const;
00108
00110 mln_value(I) to_value() const;
00111
00112 protected:
00113 I& ima_;
00114 mln_psite(I) p_;
00115 };
00116
00117
00118
00123 template <typename I>
00124 class proxy< const I > : public Value< proxy<const I> >
00125 {
00126 public:
00127
00129 typedef void enc;
00130
00132 typedef mln_value(I) equiv;
00133
00135 proxy(const I& ima, const mln_psite(I)& p);
00136
00138 ~proxy();
00139
00141 template <typename V>
00142 operator V() const;
00143
00145 operator mln_value(I)() const;
00146
00148 mln_value(I) to_value() const;
00149
00150 protected:
00151 const I& ima_;
00152 mln_psite(I) p_;
00153 };
00154
00155
00156
00157 template <typename I>
00158 bool operator==(const proxy<I>& lhs, const mln_value(I)& rhs);
00159
00160 template <typename I>
00161 bool operator==(const mln_value(I)& lhs, const proxy<I>& rhs);
00162
00163 template <typename I, typename J>
00164 bool operator==(const proxy<I>& lhs, const proxy<J>& rhs);
00165
00166
00167 template <typename I>
00168 bool operator<(const proxy<I>& lhs, const mln_value(I)& rhs);
00169
00170 template <typename I>
00171 bool operator<(const mln_value(I)& lhs, const proxy<I>& rhs);
00172
00173 template <typename I, typename J>
00174 bool operator<(const proxy<I>& lhs, const proxy<J>& rhs);
00175
00176
00177
00178
00179
00180
00188 template <typename I>
00189 std::ostream& operator<<(std::ostream& ostr, const proxy<I>& x);
00190
00191
00192 # ifndef MLN_INCLUDE_ONLY
00193
00194
00195
00196 template <typename I>
00197 inline
00198 proxy<I>::proxy(I& ima, const mln_psite(I)& p)
00199 : ima_(ima),
00200 p_(p)
00201 {
00202 }
00203
00204 template <typename I>
00205 inline
00206 proxy<I>::~proxy()
00207 {
00208 mln_rvalue(I) (I::*mr)(const mln_psite(I)&) const = & I::read_;
00209 mr = 0;
00210 void (I::*mw)(const mln_psite(I)&, const mln_value(I)&) = & I::write_;
00211 mw = 0;
00212 }
00213
00214 template <typename I>
00215 template <typename V>
00216 inline
00217 proxy<I>&
00218 proxy<I>::operator=(const V& v)
00219 {
00220 ima_.write_(p_, v);
00221 return *this;
00222 }
00223
00224 template <typename I>
00225 inline
00226 proxy<I>&
00227 proxy<I>::operator=(const proxy<I>& rhs)
00228 {
00229 this->operator=(rhs.to_value());
00230 return *this;
00231 }
00232
00233 template <typename I>
00234 template <typename II>
00235 inline
00236 proxy<I>&
00237 proxy<I>::operator=(const proxy<II>& rhs)
00238 {
00239 this->operator=(rhs.to_value());
00240 return *this;
00241 }
00242
00243 template <typename I>
00244 template <typename V>
00245 inline
00246 proxy<I>::operator V() const
00247 {
00248 return ima_.read_(p_);
00249 }
00250
00251 template <typename I>
00252 inline
00253 proxy<I>::operator mln_value(I)() const
00254 {
00255 return ima_.read_(p_);
00256 }
00257
00258 template <typename I>
00259 inline
00260 mln_value(I)
00261 proxy<I>::to_value() const
00262 {
00263 return ima_.read_(p_);
00264 }
00265
00266
00267
00268 template <typename I>
00269 inline
00270 proxy<const I>::proxy(const I& ima, const mln_psite(I)& p)
00271 : ima_(ima),
00272 p_(p)
00273 {
00274 }
00275
00276 template <typename I>
00277 inline
00278 proxy<const I>::~proxy()
00279 {
00280 mln_rvalue(I) (I::*mr)(const mln_psite(I)&) const = & I::read_;
00281 mr = 0;
00282 }
00283
00284 template <typename I>
00285 template <typename V>
00286 inline
00287 proxy<const I>::operator V() const
00288 {
00289 return ima_.read_(p_);
00290 }
00291
00292 template <typename I>
00293 inline
00294 proxy<const I>::operator mln_value(I)() const
00295 {
00296 return ima_.read_(p_);
00297 }
00298
00299 template <typename I>
00300 inline
00301 mln_value(I)
00302 proxy<const I>::to_value() const
00303 {
00304 return ima_.read_(p_);
00305 }
00306
00307
00308
00309 template <typename I>
00310 inline
00311 std::ostream& operator<<(std::ostream& ostr, const proxy<I>& x)
00312 {
00313 return ostr << x.to_value();
00314 }
00315
00316
00317
00318 template <typename I>
00319 inline
00320 bool operator==(const proxy<I>& lhs, const mln_value(I)& rhs)
00321 {
00322 return lhs.to_value() == rhs;
00323 }
00324
00325 template <typename I>
00326 inline
00327 bool operator==(const mln_value(I)& lhs, const proxy<I>& rhs)
00328 {
00329 return lhs == rhs.to_value();
00330 }
00331
00332 template <typename I, typename J>
00333 inline
00334 bool operator==(const proxy<I>& lhs, const proxy<J>& rhs)
00335 {
00336 return lhs.to_value() == rhs.to_value();
00337 }
00338
00339
00340
00341 template <typename I>
00342 inline
00343 bool operator<(const proxy<I>& lhs, const mln_value(I)& rhs)
00344 {
00345 return lhs.to_value() < rhs;
00346 }
00347
00348 template <typename I>
00349 inline
00350 bool operator<(const mln_value(I)& lhs, const proxy<I>& rhs)
00351 {
00352 return lhs < rhs.to_value();
00353 }
00354
00355 template <typename I, typename J>
00356 inline
00357 bool operator<(const proxy<I>& lhs, const proxy<J>& rhs)
00358 {
00359 return lhs.to_value() < rhs.to_value();
00360 }
00361
00362 # endif // ! MLN_INCLUDE_ONLY
00363
00364 }
00365
00366 }
00367
00368
00369 #endif // ! MLN_VALUE_PROXY_HH