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_CONVERT_FROM_TO_HH
00027 # define MLN_CONVERT_FROM_TO_HH
00028
00038
00039 # include <mln/convert/impl/all.hh>
00040 # include <mln/convert/from_to.hxx>
00041
00042 # include <mln/metal/abort.hh>
00043 # include <mln/metal/converts_to.hh>
00044 # include <mln/metal/is.hh>
00045 # include <mln/metal/is_a.hh>
00046
00047
00048 namespace mln
00049 {
00050
00051
00052 template <typename E> struct Object;
00053 template <typename E> struct Value;
00054 template <typename E> struct Site_Set;
00055 template <typename E> struct Image;
00056
00057 namespace convert
00058 {
00059
00060 template <typename F, typename T>
00061 void
00062 from_to(const F& from, T& to);
00063
00064
00065 # ifndef MLN_INCLUDE_ONLY
00066
00067 namespace internal
00068 {
00069
00070
00071
00072
00073 template <typename I, typename S>
00074 inline
00075 void
00076 from_to_dispatch(const Image<I>& from, Site_Set<S>& to)
00077 {
00078 mlc_is(mln_trait_site_set_contents(S),
00079 mln::trait::site_set::contents::dynamic)::check();
00080 mln_precondition(exact(from).is_valid());
00081 mln::convert::impl::from_image_to_site_set(from, to);
00082 }
00083
00084
00085
00086 template <typename S, typename I>
00087 inline
00088 void
00089 from_to_dispatch(const Site_Set<S>& from, Image<I>& to)
00090 {
00091 mlc_converts_to(mln_site(S), mln_site(I))::check();
00092 mln_precondition(exact(from).is_valid());
00093 mln::convert::impl::from_site_set_to_image(from, to);
00094 }
00095
00096
00097
00098 template <typename F, typename T>
00099 inline
00100 void
00101 from_to_dispatch(const Value<F>& from, Value<T>& to)
00102 {
00103 mln::convert::impl::from_value_to_value(from, to);
00104 }
00105
00106
00107
00108
00109
00110
00111
00112 template <typename F, typename T>
00113 inline
00114 void
00115 from_to_dispatch(metal::true_,
00116 const Object<F>& from, Object<T>& to)
00117 {
00118 exact(to) = exact(from);
00119 }
00120
00121
00122
00123 template <typename F, typename T>
00124 inline
00125 void
00126 from_to_dispatch(metal::false_,
00127 const Object<F>& from, Object<T>& to)
00128 {
00129 over_load::from_to_(exact(from), exact(to));
00130 }
00131
00132
00133
00134
00135
00136
00137 template <typename F, typename T>
00138 inline
00139 void
00140 from_to_dispatch(const Object<F>& from, Object<T>& to)
00141 {
00142 typedef mlc_converts_to(F, T) F_converts_to_T;
00143 internal::from_to_dispatch(F_converts_to_T(),
00144 exact(from), exact(to));
00145 }
00146
00147
00148
00149
00150
00151
00152
00153 template <typename F, typename T>
00154 inline
00155 void
00156 from_to_dispatch(metal::false_, const F& from,
00157 metal::false_, T& to)
00158 {
00159 over_load::from_to_(from, to);
00160 }
00161
00162
00163
00164 template <typename F, typename T>
00165 inline
00166 void
00167 from_to_dispatch(metal::true_, const F& from,
00168 metal::false_, T& to)
00169 {
00170 over_load::from_to_(exact(from), to);
00171 }
00172
00173
00174
00175 template <typename F, typename T>
00176 inline
00177 void
00178 from_to_dispatch(metal::false_, const F& from,
00179 metal::true_, T& to)
00180 {
00181 over_load::from_to_(from, exact(to));
00182 }
00183
00184
00185 template <typename F, typename T>
00186 inline
00187 void
00188 from_to_dispatch(metal::true_, const F& from,
00189 metal::true_, T& to)
00190 {
00191 internal::from_to_dispatch(exact(from), exact(to));
00192 }
00193
00194
00195 }
00196
00197
00198 namespace over_load
00199 {
00200
00201
00202
00203
00204 template <typename F, typename T>
00205 void
00206 from_to_(const Object<F>&, Object<T>&)
00207 {
00208
00209
00210
00211
00212 mlc_abort(F)::check();
00213 }
00214
00215
00216
00217 template <typename T>
00218 inline
00219 void
00220 from_to_(const Object<T>& from, Object<T>& to)
00221 {
00222 exact(to) = exact(from);
00223 }
00224
00225 template <typename T>
00226 inline
00227 void
00228 from_to_(const T& from, T& to)
00229 {
00230 to = from;
00231 }
00232
00233
00234 }
00235
00236
00237
00238
00239
00240 template <typename F, typename T>
00241 inline
00242 void
00243 from_to(const F& from, T& to)
00244 {
00245 typedef mlc_is_a(F, Object) F_is_object;
00246 typedef mlc_is_a(T, Object) T_is_object;
00247 internal::from_to_dispatch(F_is_object(), from,
00248 T_is_object(), to);
00249 }
00250
00251
00252 # endif // ! MLN_INCLUDE_ONLY
00253
00254 }
00255
00256 }
00257
00258
00259 #endif // ! MLN_CONVERT_FROM_TO_HH