00001 #ifndef VIENNAGRID_IO_DATA_ACCESSOR_HPP
00002 #define VIENNAGRID_IO_DATA_ACCESSOR_HPP
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <fstream>
00023 #include <sstream>
00024 #include <iostream>
00025 #include "viennagrid/domain.hpp"
00026 #include "viennagrid/forwards.h"
00027 #include "viennagrid/iterators.hpp"
00028 #include "viennagrid/io/helper.hpp"
00029 #include "viennagrid/io/vtk_common.hpp"
00030 #include "viennagrid/traits/container.hpp"
00031
00032 #include "viennadata/api.hpp"
00033
00038 namespace viennagrid
00039 {
00040 namespace io
00041 {
00042
00047 template <typename ElementType>
00048 class data_accessor_interface
00049 {
00050 public:
00051 virtual std::string operator()(ElementType const & element, std::size_t segment_id) const = 0;
00052 virtual void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const = 0;
00053
00054
00055
00056 virtual data_accessor_interface<ElementType> * clone() const = 0;
00057
00058 virtual ~data_accessor_interface() {};
00059 };
00060
00061
00062
00069 template <typename ElementType, typename KeyType, typename DataType>
00070 class global_scalar_data_accessor : public data_accessor_interface<ElementType>
00071 {
00072 typedef global_scalar_data_accessor<ElementType, KeyType, DataType> self_type;
00073
00074 public:
00075 global_scalar_data_accessor(KeyType const & k) : key_(k) {}
00076
00077
00078 std::string operator()(ElementType const & element, std::size_t segment_id) const
00079 {
00080 std::stringstream ss;
00081 ss << viennadata::access<KeyType, DataType>(key_)(element);
00082 return ss.str();
00083 }
00084
00085 void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00086 {
00087 viennadata::access<KeyType, DataType>(key_)(element) = static_cast<DataType>(value);
00088 }
00089
00090 data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00091
00092 private:
00093 KeyType key_;
00094 };
00095
00102 template <typename ElementType, typename KeyType, typename DataType>
00103 class global_vector_data_accessor : public data_accessor_interface<ElementType>
00104 {
00105 typedef global_vector_data_accessor<ElementType, KeyType, DataType> self_type;
00106
00107 public:
00108 global_vector_data_accessor(KeyType const & k) : key_(k) {}
00109
00110
00111 std::string operator()(ElementType const & element, std::size_t segment_id) const
00112 {
00113 std::stringstream ss;
00114 viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element), 3);
00115 ss << viennadata::access<KeyType, DataType>(key_)(element)[0] << " ";
00116 if (viennagrid::traits::size(viennadata::access<KeyType, DataType>(key_)(element)) > 1)
00117 ss << viennadata::access<KeyType, DataType>(key_)(element)[1] << " ";
00118 else
00119 ss << "0 ";
00120 if (viennagrid::traits::size(viennadata::access<KeyType, DataType>(key_)(element)) > 2)
00121 ss << viennadata::access<KeyType, DataType>(key_)(element)[2] << " ";
00122 else
00123 ss << "0 ";
00124 return ss.str();
00125 }
00126
00127 void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00128 {
00129 viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element), 3);
00130 viennadata::access<KeyType, DataType>(key_)(element)[k] = value;
00131 }
00132
00133 data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00134
00135 private:
00136 KeyType key_;
00137 };
00138
00139
00146 template <typename ElementType, typename KeyType, typename DataType>
00147 class segment_scalar_data_accessor : public data_accessor_interface<ElementType>
00148 {
00149 typedef segment_scalar_data_accessor<ElementType, KeyType, DataType> self_type;
00150
00151 public:
00152 segment_scalar_data_accessor(KeyType const & k) : key_(k) {}
00153
00154
00155 std::string operator()(ElementType const & element, std::size_t segment_id) const
00156 {
00157 std::stringstream ss;
00158 ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id];
00159 return ss.str();
00160 }
00161
00162 void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00163 {
00164 viennadata::access<KeyType, DataType>(key_)(element)[segment_id] = value;
00165 }
00166
00167 data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00168
00169 private:
00170 KeyType key_;
00171 };
00172
00179 template <typename ElementType, typename KeyType, typename DataType>
00180 class segment_vector_data_accessor : public data_accessor_interface<ElementType>
00181 {
00182 typedef segment_vector_data_accessor<ElementType, KeyType, DataType> self_type;
00183
00184 public:
00185 segment_vector_data_accessor(KeyType const & k) : key_(k) {}
00186
00187
00188 std::string operator()(ElementType const & element, std::size_t segment_id) const
00189 {
00190 std::stringstream ss;
00191 viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element)[segment_id], 3);
00192
00193 ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][0] << " ";
00194 ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][1] << " ";
00195 ss << viennadata::access<KeyType, DataType>(key_)(element)[segment_id][2];
00196 return ss.str();
00197 }
00198
00199 void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00200 {
00201 viennagrid::traits::resize(viennadata::access<KeyType, DataType>(key_)(element)[segment_id], 3);
00202 viennadata::access<KeyType, DataType>(key_)(element)[segment_id][k] = value;
00203 }
00204
00205 data_accessor_interface<ElementType> * clone() const { return new self_type(key_); }
00206
00207 private:
00208 KeyType key_;
00209 };
00210
00215 template <typename ElementType>
00216 class data_accessor_wrapper
00217 {
00218 public:
00219 template <typename T>
00220 data_accessor_wrapper(T const * t) : functor_(t) {}
00221
00222 data_accessor_wrapper() {}
00223
00224 data_accessor_wrapper(const data_accessor_wrapper & other) : functor_(other.clone()) {}
00225
00226 data_accessor_wrapper & operator=(data_accessor_wrapper const & other)
00227 {
00228 functor_ = std::auto_ptr< const data_accessor_interface<ElementType> >(other.clone());
00229 return *this;
00230 }
00231
00232 std::string operator()(ElementType const & element, std::size_t segment_id = 0) const
00233 {
00234 return functor_->operator()(element, segment_id);
00235 }
00236
00237 void operator()(ElementType const & element, std::size_t segment_id, std::size_t k, double value) const
00238 {
00239 functor_->operator()(element, segment_id, k, value);
00240 }
00241
00242 data_accessor_interface<ElementType> * clone() const { return functor_->clone(); }
00243
00244 private:
00245 std::auto_ptr< const data_accessor_interface<ElementType> > functor_;
00246 };
00247
00248 }
00249 }
00250
00251 #endif