FMDataSerialize.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
#ifndef _FM_DATA_SERIALIZE_
#define _FM_DATA_SERIALIZE_
 
#include <OdaCommon.h>
#include "OdPlatformSettings.h"
#include "Modeler/FMMdlBody.h"
#include "Modeler/FMMdlVertex.h"
#include <map>
 
namespace FacetModeler
{
  typedef OdUInt64 KeyType;
 
  struct VertexImage
  {
    VertexImage() : pVtx(NULL), pPrev(0), pNext(0), pKey(0)
    {}
    Vertex* pVtx;  // Vertex pointer.
    KeyType pKey;  // Key.
    KeyType pPrev; // Previous key.
    KeyType pNext; // Next key.
  };
 
  struct EdgeImage
  {
    EdgeImage() : pEdge(NULL), pFaceKey(0), pLoopKey(0),
      pVertexKey(0), pPrevKey(0), pNextKey(0), pPairKey(0), pPartnerKey(0)
    {}
 
    Edge* pEdge; // Edge pointer.
    KeyType pFaceKey; // Face key.
    KeyType pLoopKey; // Loop key.
    KeyType pVertexKey; // Vertex key.
    KeyType pPrevKey; // Previous key.
    KeyType pNextKey; // Next key.
    KeyType pPairKey; // Pair key.
    KeyType pPartnerKey; // Partner key.
  };
 
  struct LoopImage
  {
    LoopImage() : pLoopKey(0)
    {}
 
    KeyType pLoopKey; // Loop key.
    std::vector<KeyType> edgeKeys; // Edge key array.
  };
 
  typedef std::vector<LoopImage> LoopImages;
 
  struct FaceImage
  {
    FaceImage() : pFace(NULL),pFaceKey(0),  pPrevKey(0), pNextKey(0)
    {}
 
    Face* pFace; // Face pointer.
    KeyType pFaceKey; // Face key.
    KeyType pPrevKey; // Previous key.
    KeyType pNextKey; // Next key.
 
    LoopImages loopImages; // Loop images.
  };
 
  typedef std::vector<VertexImage> VertexImages;
 
  typedef std::map<KeyType, EdgeImage> EdgeImages;
 
  typedef std::vector<FaceImage> FaceImages;
 
  class FMGEOMETRY_API BinaryStream
  {
  public:
    
    enum OdaObjectMarker
    {
      ePoint2dMarker = 1,
 
      eContour2dMarker = 2,
 
      eProfile2dMarker = 3,
 
      eBodyMarker = 4,
 
      eFaceMarker = 5,
 
      ePoint3dMarker = 6
    };
 
    enum Version
    {
      v64bit = -2,
 
      v32bit = -1,
 
      vAuto = 0,
 
      vKeyTypeAdded = 1,
 
      vSaveColorsAdded = 2,
 
      vCurrent = 2,
    };
 
    static const OdUInt32 iSigLen = 4; // Signature length in bytes
    static const OdUInt32 iVerLen = 2; // Version length in bytes
 
    BinaryStream();
    
    ~BinaryStream();
 
    bool Create(const OdString& szFile);
 
    bool Open(const OdString& szFile, Version ver = vAuto);
 
    
    bool Open(OdStreamBuf* pFileBuff, Version ver = vAuto);
 
    bool Create(OdStreamBuf* pFileBuff);
 
    bool Reset(Version ver = vAuto);
 
    inline Version getVersion() const
    {
      return m_iVersion;
    };
 
    void Write(const void* pData, OdUInt32 length);
 
    void Read(void* pData, OdUInt32 length);
 
    template<typename T>
    void Write(const T val)
    {
      Write(&val, sizeof(val));
    }
 
    void Write(const OdGePoint2d& val);
    
    void Write(const Contour2D& val);
    
    void Write(const Profile2D& val);
 
    void Write(const OdGePoint3d& val);
    
    void Write(const Face& val);
    
    void Write(const Body& val);
 
    void WriteVertexList(Vertex* pVertexList, OdUInt32 uVtxCount);
    
    void WriteVertex(Vertex* pVertex);
    
    void WriteEdgesList(const Body& val);
    
    void WriteEdge(Edge* pEdge);
 
    template<typename T>
    void Read(T& val)
    {
      Read(&val, sizeof(val));
    }
 
    void Read(OdGePoint2d& val);
    
    void Read(Contour2D& val);
    void Read(Profile2D& val);
 
    void Read(OdGePoint3d& val);
 
    void ReadFaceToBody(Body& val);
 
    void Read(Body& val);
 
    void ReadKey(KeyType& val);
 
    void ReadVertexImages(VertexImages& vertexImages, Body* pBody);
 
    void SetVertexListForBody(VertexImages& vertexImages, Body& val);
 
    void ReadEdgeImages(EdgeImages& edgeImages);
 
    void ReadFaceImages(FaceImages& faceImages);
  private:
    OdStreamBufPtr m_pStream; // Pointer to the stream buffer
    Version m_iVersion;       // Current version
  };
 
} // ::
#endif //_FM_DATA_SERIALIZE_