AFEPack
Serialization.h
浏览该文件的文档。
00001 
00019 #ifdef __SERIALIZATION__
00020 #ifndef __Serialization_h__
00021 #define __Serialization_h__
00022 
00023 #include <boost/serialization/base_object.hpp>
00024 #include <boost/serialization/utility.hpp>
00025 #include <boost/serialization/vector.hpp>
00026 #include <boost/serialization/list.hpp>
00027 #include <boost/serialization/map.hpp>
00028 
00029 #include "HGeometry.h"
00030 
00031 namespace boost {
00032   namespace serialization {
00033 
00037     template <class AR, int DOW> void
00038       serialize(AR& ar, 
00039                 Point<DOW>& pnt, 
00040                 const u_int version) {
00041       for (int i = 0;i < DOW;++ i) {
00042         ar & pnt[i];
00043       }
00044     }
00045 
00050     template <class AR, class T> void
00051       serialize(AR& ar, 
00052                 BinaryBuffer<T>& buf, 
00053                 const u_int version) {
00054       ar & boost::serialization::base_object<typename BinaryBuffer<T>::_Base>(buf);;
00055     }
00056 
00060     template <class AR, int DIM, int DOW> void 
00061       serialize(AR& ar, 
00062                 HGeometry<DIM,DOW>& hg, 
00063                 const u_int version) {
00064       ar & hg.buffer;
00065 
00066       ar & hg.index;
00067       ar & hg.vertex;
00068       ar & hg.boundary;
00069       ar & hg.parent;
00070       ar & hg.child;
00071       ar & hg.bmark;
00072     }
00073 
00077     template <class AR, int DOW> void
00078       serialize(AR& ar, 
00079                 HGeometry<0,DOW>& hg, 
00080                 const u_int version) {
00081       ar & hg.buffer;
00082 
00083       ar & boost::serialization::base_object<Point<DOW> >(hg);
00084       ar & hg.index;
00085       ar & hg.bmark;
00086     }
00087 
00095     template <class AR, int DIM, int DOW> void
00096       serialize(AR& ar, 
00097                 HGeometryTree<DIM,DOW>& ht, 
00098                 const u_int version) {
00099       ar & ht.rootElement();
00100       ar & ht.is_locked();
00101     }
00102 
00110     template <class AR, int DIM, int DOW> void
00111       load(AR& ar,
00112            HGeometryTree<DIM,DOW>& tree,
00113            const u_int version = 0) {
00114       u_int n_root_ele;
00115       ar & n_root_ele;
00116       for (u_int i = 0;i < n_root_ele;++ i) {
00117         HGeometry<DIM,DOW> * ele = new HGeometry<DIM,DOW>();
00118         ar & *ele;
00119         tree.rootElement().push_back(ele);
00120       }
00121     }
00122 
00123 
00133     template <class AR, int DIM, int DOW> void
00134       save(AR& ar,
00135            HGeometryTree<DIM,DOW>& tree,
00136            int start, 
00137            int end,
00138            const u_int version = 0) {
00139       u_int n_root_ele = end - start;
00140       typename HGeometryTree<DIM,DOW>::RootIterator
00141         the_root_ele = tree.beginRootElement();
00142       std::advance(the_root_ele, start);
00143 
00144       ar & n_root_ele;
00145       for (u_int i = 0;i < n_root_ele;++ i) {
00146         ar & *the_root_ele;
00147         ++ the_root_ele;
00148       }
00149     }
00150 
00154     template <class AR, int DIM, int DOW> void 
00155       serialize(AR& ar, 
00156                 HElement<DIM,DOW>& he, 
00157                 const u_int version) {
00158       ar & he.index;
00159       ar & he.indicator;
00160       ar & he.value;
00161       ar & he.h_element;
00162       ar & he.parent;
00163       ar & he.child;
00164     }
00165 
00173     template <class AR, int DIM, int DOW> void
00174       serialize(AR& ar, 
00175                 IrregularMesh<DIM,DOW>& im, 
00176                 const u_int version) {
00177       ar & im.rootElement();
00178       ar & &(im.geometryTree());
00179     }
00180 
00188     template <class AR, int DIM, int DOW> void
00189       load(AR& ar,
00190            IrregularMesh<DIM,DOW>& im,
00191            const u_int version = 0) {
00192       u_int n_root_ele;
00193       ar & n_root_ele;
00194       for (u_int i = 0;i < n_root_ele;++ i) {
00195         HElement<DIM,DOW> * ele = new HElement<DIM,DOW>();
00196         ar & *ele;
00197         im.rootElement().push_back(ele);
00198       }
00199     }
00200 
00201 
00211     template <class AR, int DIM, int DOW> void
00212       save(AR& ar,
00213            IrregularMesh<DIM,DOW>& im,
00214            int start, 
00215            int end,
00216            const u_int version = 0) {
00217       u_int n_root_ele = end - start;
00218       typename IrregularMesh<DIM,DOW>::RootIterator
00219         the_root_ele = im.beginRootElement();
00220       std::advance(the_root_ele, start);
00221 
00222       ar & n_root_ele;
00223       for (u_int i = 0;i < n_root_ele;++ i) {
00224         ar & *the_root_ele;
00225         ++ the_root_ele;
00226       }
00227     }
00228 
00229   }
00230 }
00231 #endif // __Serialization_h__
00232 #endif // __SERIALIZATION__
00233