serialization.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2015:  G-CSC, Goethe University Frankfurt
 * Author: Sebastian Reiter
 * 
 * This file is part of UG4.
 * 
 * UG4 is free software: you can redistribute it and/or modify it under the
 * terms of the GNU Lesser General Public License version 3 (as published by the
 * Free Software Foundation) with the following additional attribution
 * requirements (according to LGPL/GPL v3 §7):
 * 
 * (1) The following notice must be displayed in the Appropriate Legal Notices
 * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (2) The following notice must be displayed at a prominent place in the
 * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
 * 
 * (3) The following bibliography is recommended for citation and must be
 * preserved in all covered files:
 * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
 *   parallel geometric multigrid solver on hierarchically distributed grids.
 *   Computing and visualization in science 16, 4 (2013), 151-164"
 * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
 *   flexible software system for simulating pde based models on high performance
 *   computers. Computing and visualization in science 16, 4 (2013), 165-179"
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 */
 
#ifndef __H__LIB_GRID__SERIALIZATION__
#define __H__LIB_GRID__SERIALIZATION__
 
#include <iostream>
#include "common/util/smart_pointer.h"
#include "common/util/binary_buffer.h"
#include "common/serialization.h"
#include "lib_grid/grid_objects/grid_objects.h"
#include "lib_grid/tools/subset_handler_interface.h"
#include "lib_grid/tools/selector_interface.h"
#include "lib_grid/multi_grid.h"
#include "lib_grid/common_attachments.h"
#include "lib_grid/algorithms/attachment_util.h"
#include "lib_grid/parallelization/grid_object_id.h"
// #include "lib_grid/refinement/projectors/refinement_projector.h"
// #include "lib_grid/refinement/projectors/projection_handler.h"
 
namespace ug
{
 
//  Utilities
 
template <class TGeomObj>
class GeomObjDataSerializer
{
  public:
    virtual ~GeomObjDataSerializer()  {}
 
 
    virtual void write_info(BinaryBuffer& out) const {};
    virtual void write_data(BinaryBuffer& out, TGeomObj* o) const = 0;
 
    virtual void read_info(BinaryBuffer& in)  {};
    virtual void read_data(BinaryBuffer& in, TGeomObj* o) = 0;
 
    virtual void deserialization_starts()         {}
 
    virtual void deserialization_done()           {}
};
class GeomObjDataSerializer {…};
 
typedef GeomObjDataSerializer<Vertex> VertexDataSerializer;
typedef GeomObjDataSerializer<Edge>   EdgeDataSerializer;
typedef GeomObjDataSerializer<Face>     FaceDataSerializer;
typedef GeomObjDataSerializer<Volume>   VolumeDataSerializer;
 
typedef SmartPtr<VertexDataSerializer>  SPVertexDataSerializer;
typedef SmartPtr<EdgeDataSerializer>  SPEdgeDataSerializer;
typedef SmartPtr<FaceDataSerializer>  SPFaceDataSerializer;
typedef SmartPtr<VolumeDataSerializer>  SPVolumeDataSerializer;
 
class GridDataSerializer
{
  public:
    virtual ~GridDataSerializer() {}
 
 
    virtual void write_info(BinaryBuffer& out) const        {}
 
    virtual void read_info(BinaryBuffer& in)          {}
 
    virtual void write_data(BinaryBuffer& out, Vertex* o) const {}
    virtual void write_data(BinaryBuffer& out, Edge* o) const {}
    virtual void write_data(BinaryBuffer& out, Face* o) const   {}
    virtual void write_data(BinaryBuffer& out, Volume* o) const   {}
 
    virtual void read_data(BinaryBuffer& in, Vertex* o) {}
    virtual void read_data(BinaryBuffer& in, Edge* o) {}
    virtual void read_data(BinaryBuffer& in, Face* o)   {}
    virtual void read_data(BinaryBuffer& in, Volume* o)   {}
 
    virtual void deserialization_starts()         {}
 
    virtual void deserialization_done()           {}
};
class GridDataSerializer {…};
 
typedef SmartPtr<GridDataSerializer>  SPGridDataSerializer;
 
 
 
class GridDataSerializationHandler
{
  public:
    ~GridDataSerializationHandler() {}
 
 
    void add(SPVertexDataSerializer cb);
    void add(SPEdgeDataSerializer cb);
    void add(SPFaceDataSerializer cb);
    void add(SPVolumeDataSerializer cb);
    void add(SPGridDataSerializer cb);
    void write_infos(BinaryBuffer& out) const;
 
    inline void serialize(BinaryBuffer& out, Vertex* vrt) const;
    inline void serialize(BinaryBuffer& out, Edge* edge) const;
    inline void serialize(BinaryBuffer& out, Face* face) const;
    inline void serialize(BinaryBuffer& out, Volume* vol) const;
 
    template <class TIterator>
    void serialize(BinaryBuffer& out, TIterator begin, TIterator end) const;
 
    void serialize(BinaryBuffer& out, GridObjectCollection goc) const;
 
    void read_infos(BinaryBuffer& in);
 
    inline void deserialize(BinaryBuffer& in, Vertex* vrt);
    inline void deserialize(BinaryBuffer& in, Edge* edge);
    inline void deserialize(BinaryBuffer& in, Face* face);
    inline void deserialize(BinaryBuffer& in, Volume* vol);
 
    template <class TIterator>
    void deserialize(BinaryBuffer& in, TIterator begin, TIterator end);
 
    void deserialize(BinaryBuffer& in, GridObjectCollection goc);
 
    void deserialization_starts();
 
    void deserialization_done();
 
  private:
    template<class TGeomObj, class TSerializers>
    void serialize(BinaryBuffer& out, TGeomObj* o,
             TSerializers& serializers) const;
 
    template<class TGeomObj, class TDeserializers>
    void deserialize(BinaryBuffer& in, TGeomObj* o,
             TDeserializers& deserializers);
 
    template<class TSerializers>
    void write_info(BinaryBuffer& out, TSerializers& serializers) const;
 
    template<class TSerializers>
    void read_info(BinaryBuffer& in, TSerializers& serializers);
 
    template<class TSerializers>
    void deserialization_starts(TSerializers& serializers);
 
    template<class TSerializers>
    void deserialization_done(TSerializers& serializers);
 
  private:
    std::vector<SPVertexDataSerializer> m_vrtSerializers;
    std::vector<SPEdgeDataSerializer> m_edgeSerializers;
    std::vector<SPFaceDataSerializer> m_faceSerializers;
    std::vector<SPVolumeDataSerializer> m_volSerializers;
    std::vector<SPGridDataSerializer> m_gridSerializers;
};
class GridDataSerializationHandler {…};
 
 
 
template <class TGeomObj, class TAttachment>
class GeomObjAttachmentSerializer :
  public GeomObjDataSerializer<TGeomObj>
{
  public:
    static SmartPtr<GeomObjDataSerializer<TGeomObj> >
    create(Grid& g, TAttachment a)
    {return SmartPtr<GeomObjDataSerializer<TGeomObj> >(new GeomObjAttachmentSerializer(g, a));}
    create(Grid& g, TAttachment a) {…}
 
    GeomObjAttachmentSerializer(Grid& g, TAttachment a) :
      m_aa(g, a, true)  {}
    GeomObjAttachmentSerializer(Grid& g, TAttachment a) : {…}
 
    virtual ~GeomObjAttachmentSerializer() {};
 
    virtual void write_data(BinaryBuffer& out, TGeomObj* o) const
    {Serialize(out, m_aa[o]);}
    virtual void write_data(BinaryBuffer& out, TGeomObj* o) const {…}
 
    virtual void read_data(BinaryBuffer& in, TGeomObj* o)
    {Deserialize(in, m_aa[o]);}
    virtual void read_data(BinaryBuffer& in, TGeomObj* o) {…}
 
  private:
    Grid::AttachmentAccessor<TGeomObj, TAttachment> m_aa;
};
class GeomObjAttachmentSerializer : {…};
 
class SubsetHandlerSerializer : public GridDataSerializer
{
  public:
    static SPGridDataSerializer create(ISubsetHandler& sh)
    {return SPGridDataSerializer(new SubsetHandlerSerializer(sh));}
    static SPGridDataSerializer create(ISubsetHandler& sh) {…}
 
    SubsetHandlerSerializer(ISubsetHandler& sh);
 
    virtual void write_info(BinaryBuffer& out) const;
 
    virtual void read_info(BinaryBuffer& in);
 
    virtual void write_data(BinaryBuffer& out, Vertex* o) const;
    virtual void write_data(BinaryBuffer& out, Edge* o) const;
    virtual void write_data(BinaryBuffer& out, Face* o) const;
    virtual void write_data(BinaryBuffer& out, Volume* o) const;
 
    virtual void read_data(BinaryBuffer& in, Vertex* o);
    virtual void read_data(BinaryBuffer& in, Edge* o);
    virtual void read_data(BinaryBuffer& in, Face* o);
    virtual void read_data(BinaryBuffer& in, Volume* o);
 
  private:
    ISubsetHandler& m_sh;
};
class SubsetHandlerSerializer : public GridDataSerializer {…};
 
//  GRID
 
 
bool SerializeGridElements(Grid& grid, GridObjectCollection goc,
               AInt& aIntVRT, BinaryBuffer& out);
 
bool SerializeGridElements(Grid& grid, BinaryBuffer& out);
 
 
bool SerializeGridElements(Grid& grid, GridObjectCollection goc,
               BinaryBuffer& out);
 
 
bool DeserializeGridElements(Grid& grid, BinaryBuffer& in,
              bool readGridHeader = true);
 
 
//  MULTI-GRID
 
//  SerializeMultiGridElements
 
bool SerializeMultiGridElements(MultiGrid& mg,
                GridObjectCollection goc,
                MultiElementAttachmentAccessor<AInt>& aaInt,
                BinaryBuffer& out,
                MultiElementAttachmentAccessor<AGeomObjID>* paaID = NULL);
 
//  SerializeMultiGridElements
 
bool SerializeMultiGridElements(MultiGrid& mg,
                GridObjectCollection goc,
                BinaryBuffer& out);
 
//  SerializeMultiGridElements
bool SerializeMultiGridElements(MultiGrid& mg,
                BinaryBuffer& out);
                
 
bool DeserializeMultiGridElements(MultiGrid& mg, BinaryBuffer& in,
                  std::vector<Vertex*>* pvVrts = NULL,
                  std::vector<Edge*>* pvEdges = NULL,
                  std::vector<Face*>* pvFaces = NULL,
                  std::vector<Volume*>* pvVols = NULL,
                  MultiElementAttachmentAccessor<AGeomObjID>* paaID = NULL);
 
 
 
//  ATTACHMENTS
 
//  copies attached values to a binary stream.
template <class TElem, class TAttachment>
bool SerializeAttachment(Grid& grid, TAttachment& attachment,
             BinaryBuffer& out);
 
 
template <class TElem, class TAttachment>
bool SerializeAttachment(Grid& grid, TAttachment& attachment,
             typename geometry_traits<TElem>::iterator iterBegin,
             typename geometry_traits<TElem>::iterator iterEnd,
             BinaryBuffer& out);
 
 
template <class TElem, class TAttachment>
bool DeserializeAttachment(Grid& grid, TAttachment& attachment,
             BinaryBuffer& in);
 
 
template <class TElem, class TAttachment>
bool DeserializeAttachment(Grid& grid, TAttachment& attachment,
             typename geometry_traits<TElem>::iterator iterBegin,
             typename geometry_traits<TElem>::iterator iterEnd,
             BinaryBuffer& in);
 
 
//  SUBSET-HANDLER
 
bool SerializeSubsetHandler(Grid& grid, ISubsetHandler& sh,
              GridObjectCollection goc,
              BinaryBuffer& out);
              
bool SerializeSubsetHandler(Grid& grid, ISubsetHandler& sh,
              BinaryBuffer& out);
 
 
bool DeserializeSubsetHandler(Grid& grid, ISubsetHandler& sh,
              GridObjectCollection goc,
              BinaryBuffer& in,
              bool readPropertyMap = true);
 
              
 
bool DeserializeSubsetHandler(Grid& grid, ISubsetHandler& sh,
              BinaryBuffer& in,
              bool readPropertyMap = true);
 
 
//  SELECTOR
 
bool SerializeSelector(Grid& grid, ISelector& sel,
             GridObjectCollection goc,
             BinaryBuffer& out);
              
bool SerializeSelector(Grid& grid, ISelector& sel,
             BinaryBuffer& out);
 
 
bool DeserializeSelector(Grid& grid, ISelector& sel,
             GridObjectCollection goc,
             BinaryBuffer& in);
 
              
 
bool DeserializeSelector(Grid& grid, ISelector& sel,
             BinaryBuffer& in);
 
 
// void SerializeProjector(BinaryBuffer& out, RefinementProjector& proj);
// void SerializeProjectionHandler(BinaryBuffer& out, ProjectionHandler& ph);
// SPRefinementProjector DeserializeProjector(BinaryBuffer& in);
// void DeserializeProjectionHandler(BinaryBuffer& in, ProjectionHandler& ph);
 
 
}
 
//  include implementation
#include "serialization_impl.hpp"
 
#endif