TfDwgFiler.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 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 _OdTfDwgFiler_h_Included_
#define _OdTfDwgFiler_h_Included_
 
#define STL_USING_SET
#define STL_USING_STACK
#define STL_USING_STREAM
#include "OdaSTL.h"
#include "DbFiler.h"
#include "RxDynamicModule.h"
#include <OdPlatformStreamer.h>
#include "../../ThirdParty/tinyxml/tinyxml.h"
#include "Tf/Tf.h"
#include "DbHistoryManager.h"
#include "OdBinaryData.h"
#include "OdList.h"
 
 
class OdTfDwgFilerImpl;
class TiXmlDocument;
class OdTfDiffFilerImpl;
class ChangesCalculation;
 
struct BinaryDataStruct
{
  char *pBinaryData;
  OdUInt32 size;
  OdUInt32 posBinaryData;
  
};
 
class OdTfDwgFiler : public OdDbDwgFiler
{
  friend class ChangesCalculation;
  OdTfDwgFilerImpl* m_pImpl;
  ChangesCalculation* m_pChangesCalc;
  bool m_usesMultiUserEdit;
  bool m_bApplyDiff;
  bool m_bPassXmlData;
        bool m_bPassXmlDataByCondition;
        size_t m_sizeStack;
        TiXmlString m_nameStackCondition;
        OdTf::TypesEnum m_type;
  inline void checkChanges(OdTf::TypesEnum tBase, void *value, OdString string = OdString());
        void wrHexBinaryValue(const void* buffer, OdUInt32 numBytes);
        void wrHandleValue(const OdDbHandle& value);
        void wrStringValue(const OdString &value);
  void wrObjectIdValue(OdTf::TypesEnum tBase, const OdDbObjectId &id);
  template<class T>
  void wrValue(OdTf::TypesEnum tBase, const T &value, OdUInt32 countBytes = 0);
  void wrGeValue(OdTf::TypesEnum tBase, OdUInt8 countPoints , double , double , double z = 0);
 
public:
  OdTfDiffFilerImpl *m_pFilerXmlData;
  void setChangesCalc(ChangesCalculation *pointer) { m_pChangesCalc = pointer; }
  OdTfDwgFilerImpl* getImpl() {return m_pImpl;};
  bool& bApplyDiff() { return m_bApplyDiff; };
  void setUsedMUE() {m_usesMultiUserEdit = true;};
 
  ODRX_HEAP_OPERATORS();
  ODRX_DECLARE_MEMBERS(OdTfDwgFiler);
  OdTfDwgFiler();
  ~OdTfDwgFiler();
  virtual FilerType filerType() const ODRX_OVERRIDE { return kUndoFiler; }
  virtual OdDbDatabase* database() const ODRX_OVERRIDE;
  virtual void seek(OdInt64 offset, OdDb::FilerSeekType seekType) ODRX_OVERRIDE {}
  virtual OdUInt64 tell() const ODRX_OVERRIDE { return 0; }
  virtual bool rdBool() ODRX_OVERRIDE;
  virtual OdString rdString();
  virtual void rdBytes(void* buffer, OdUInt32 numBytes);
  virtual OdInt8 rdInt8();
  virtual OdUInt8 rdUInt8();
  virtual OdInt16 rdInt16();
  virtual OdInt32 rdInt32();
  virtual OdInt64 rdInt64();
  virtual void* rdAddress();
  virtual double rdDouble();
  virtual OdDbHandle rdDbHandle();
  virtual OdDbObjectId rdSoftOwnershipId();
  virtual OdDbObjectId rdHardOwnershipId();
  virtual OdDbObjectId rdHardPointerId();
  virtual OdDbObjectId rdSoftPointerId();
  virtual OdGePoint2d rdPoint2d();
  virtual OdGePoint3d rdPoint3d();
  virtual OdGeVector2d rdVector2d();
  virtual OdGeVector3d rdVector3d();
  virtual OdGeScale3d rdScale3d();
  virtual void wrBool(bool value);
  virtual void wrString(const OdString &value);
  virtual void wrBytes(const void* buffer, OdUInt32 numBytes);
  virtual void wrInt8(OdInt8 value);
  virtual void wrUInt8(OdUInt8 value);
  virtual void wrInt16(OdInt16 value);
  virtual void wrInt32(OdInt32 value);
  virtual void wrInt64(OdInt64 value);
  virtual void wrAddress(const void* value);
  virtual void wrDouble(double value);
  virtual void wrDbHandle(const OdDbHandle& value);
  virtual void wrSoftOwnershipId(const OdDbObjectId& value);
  virtual void wrHardOwnershipId(const OdDbObjectId& value);
  virtual void wrSoftPointerId(const OdDbObjectId& value);
  virtual void wrHardPointerId(const OdDbObjectId& value);
  virtual void wrPoint2d(const OdGePoint2d& value);
  virtual void wrPoint3d(
    const OdGePoint3d& value);
 
  virtual void wrVector2d(
    const OdGeVector2d& value);
 
  virtual void wrVector3d(
    const OdGeVector3d& value);
 
  virtual void wrScale3d(
    const OdGeScale3d& value);
 
  virtual bool usesReferences() const ODRX_OVERRIDE { return true; }
 
  virtual void addReference(OdDbObjectId id, OdDb::ReferenceType rt) ODRX_OVERRIDE;
 
  static TiXmlDocument* saveDwgToXml(OdDbDatabase* pDb, const char* pcszXsdFilename, OdDbObjectId idObj);
 
  // undo specific overrides
  virtual void wrDatabase(OdDbDatabase* pDb);
  virtual OdDbDatabase* rdDatabase();
  virtual void wrClass(const OdRxClass* c);
  virtual OdRxClass* rdClass();
};
 
class ChangesCalculation
{
  friend class OdTfDwgFiler;
public:  
  ChangesCalculation();
  void calculateDifference(OdDbDatabase *pDb, OdStreamBufPtr bufPtr, const char *filePath);
 
private:
  OdTfDiffFilerImpl *m_pFilerServerData;
  OdTfDwgFilerImpl *m_filer;
  OdSmartPtr<OdTfDwgFiler> m_pFiler;
  OdString m_tableName;
  OdStreamBuf *m_buf;
  bool m_bForceWrite;
        bool m_eraseFlag;
  void initParts(const char *filePath);
  
  void matchingPositionScheme(OdTf::TypesEnum &t1, OdTf::TypesEnum &t2, OdTfDwgFiler *actual);
        void writeAppendedObjectsToXml();
  void writeLogMessageToXml();
  void writeId_StringStreamsToXml();
  void parsingPartialUndo(OdInt32 &numRev, OdInt32 &nextDataStream, OdInt32 &sizeDataStream, OdInt32 &curPos, OdInt32 &nextRecPos,
    OdInt32 *massDataLengthRevision, OdInt16 &opCode, bool &partialUndo );
  void getLenghtEachRevision(OdInt32 &countRevision, OdInt32 *massDataLengthRevision);
  void isDifferentWrite(void* value, OdTf::TypesEnum t, OdString &string, const void * buf = 0x0, OdUInt32 numBytes = 0);
        void seekToNextData(OdInt32 &curPos, OdInt32 &sizeDataStream, OdInt32 &nextRecPos, OdInt32 &nextDataStream, OdInt32 & numRev, OdInt32 *massDataLenghtRevision);
 
    template <class T>
    OdString rdString(T *buf)
    {
      OdInt16 strLen;
      buf->getBytes(&strLen, 2);
      OdBinaryData buff;
      buff.resize(strLen * 2);
      buf->getBytes(buff.asArrayPtr(), buff.length());
      const OdUInt8* pBuff = buff.asArrayPtr();
      return OdPlatformStreamer::getUnicodeStrFromBuffer(pBuff, strLen);
    }
};
 
 
class ApplyChanges
{
  
public:
  ApplyChanges() {};
  ~ApplyChanges() 
  {
    //delete m_handleMap;
  };
  
  
  struct TRecordNewObject
  {
    OdString s_name;
    OdUInt32 s_pos;
    size_t s_numInList;
    TRecordNewObject() : s_pos(-1) { ; };
    TRecordNewObject(OdString name, OdUInt32 pos, size_t num)
      : s_name(name), s_pos(pos), s_numInList(num) {;};
  };
  OdDbHandleMap applyDifference(OdDbDatabase *pDb, bool bApplyDiff, bool bPreserveHandles, const char *filePath);
  static void writeData(OdTf::TypesEnum t, OdTfDwgFilerImpl *m_filer, OdTfDiffFilerImpl *schemeIter, OdString *tableNameFromXml = 0);
  template<class T>
  static inline void checkCondition(T value, OdTfDwgFilerImpl *schemeIter);
        
private:
  BinaryDataStruct m_binDataAC;
  OdTfDwgFilerImpl *m_filer;
  OdSmartPtr<OdTfDwgFiler> m_pFiler;
  OdList<std::pair<OdUInt32, char*> > m_listBinObjects;
  std::map<OdDbHandle, TRecordNewObject> m_mapCreatedObjects;
  void writePartialUndoData(OdDbHandle handle, OdString tableName, TiXmlDocument &schema);
  void appendedObjectData(OdTfDiffFilerImpl *schemeIter, OdTf::TypesEnum &t);
  void init(OdDbDatabase * pDb, TiXmlDocument &schema, TiXmlDocument &xml, TiXmlElement *pRoot, bool bApplyDiff, const char *filePath);
  void writeInformationData();
  void changeDataAddedObject(OdDbDatabase * pDb, TiXmlDocument &schema, OdString &tableName, OdDbHandle &handle);
  char* getFinalData(OdUInt32 &size, OdInt32 mergeBlockingAndMarks);
 
 
  TiXmlElement* stepBeginOfTable(TiXmlElement *e)
  {
    while (strcmp(e->Parent()->Value(), "TeighaDrawing") != 0)
      e = (TiXmlElement*)e->Parent();
    return (TiXmlElement*)e;
  }
 
  TiXmlElement* stepToLastDiffItemInPrevTable(TiXmlElement *e)
  {
    if (strcmp(e->Value(), "handleNotSystemData") == 0)
    {
      while (strcmp(e->Parent()->Value(), "TeighaDrawing") != 0)
        e = (TiXmlElement*)e->Parent();
    }
    TiXmlElement *n = (TiXmlElement*)e->PreviousSibling()->LastChild();
    do
    {
      while (n->LastChild())
        n = (TiXmlElement*)n->LastChild();
      while (n->NextSiblingElement())
        n = n->NextSiblingElement();
    } while (n->NextSiblingElement() || n->FirstChildElement());
 
    return n;
  };
  
};
 
 
 
inline OdUInt32 encodeToBase64(const unsigned char* bytesToEncode, OdUInt32 length,
  OdAnsiString& sOut, bool inQuotes = false)
{
  static const char* base64Dict = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
  //char* res = new char[len * 8 / 6 + 2];
  char* res = sOut.getBuffer(length * 8 / 6 + 4 + (inQuotes ? 2 : 0));
  if (inQuotes)
    *res++ = '\"';
 
  OdUInt32 len = length,
    finalLen = 0,
    i = 0,
    j = 0;
  unsigned char charArraySrc[3];
  unsigned char charArrayFin[4];
 
  while (len--) {
    charArraySrc[i++] = *(bytesToEncode++);
    if (i == 3) {
      charArrayFin[0] = (charArraySrc[0] & 0xfc) >> 2;
      charArrayFin[1] = ((charArraySrc[0] & 0x03) << 4) + ((charArraySrc[1] & 0xf0) >> 4);
      charArrayFin[2] = ((charArraySrc[1] & 0x0f) << 2) + ((charArraySrc[2] & 0xc0) >> 6);
      charArrayFin[3] = charArraySrc[2] & 0x3f;
 
      for (i = 0; i < 4; i++)
        res[finalLen++] = base64Dict[charArrayFin[i]];
      i = 0;
    }
  }
 
  if (i != 0)
  {
    for (j = i; j < 3; j++)
      charArraySrc[j] = '\0';
 
    charArrayFin[0] = (charArraySrc[0] & 0xfc) >> 2;
    charArrayFin[1] = ((charArraySrc[0] & 0x03) << 4) + ((charArraySrc[1] & 0xf0) >> 4);
    charArrayFin[2] = ((charArraySrc[1] & 0x0f) << 2) + ((charArraySrc[2] & 0xc0) >> 6);
    charArrayFin[3] = charArraySrc[2] & 0x3f;
 
    for (j = 0; j < i + 1; j++)
      res[finalLen++] = base64Dict[charArrayFin[j]];
 
    while ((i++ < 3))
      res[finalLen++] = '=';
  }
 
  ODA_ASSERT_ONCE(finalLen <= (length * 8 / 6 + 3));
  if (inQuotes)
  {
    res[finalLen] = '\"';
    res[finalLen + 1] = 0; // res[finalLen + 1] = 0;
    finalLen += 2;
  }
  else
    res[finalLen] = 0; // res[finalLen + 1] = 0;
 
                       //sOut.releaseBuffer();
  return finalLen;
}
 
inline OdUInt32 decodeBase64(const OdAnsiString& stringToDecode, OdBinaryData& out)
{
  static unsigned char* decode64Dict = NULL;
  if (!decode64Dict)
  {
    static const char* base64Dict = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    static OdBinaryData dataDict;
    dataDict.resize(256);
    decode64Dict = dataDict.asArrayPtr();
    for (OdUInt32 i = 0; i < 64; i++)
      decode64Dict[base64Dict[i]] = (unsigned char)i;
  }
 
  OdUInt32 length = stringToDecode.getLength();
  if (length % 4 != 0)
    return -1;
  const char* pToDecode = stringToDecode.c_str();
 
  OdUInt32 outLength = length * 3 / 4;
  outLength -= (pToDecode[length - 2] == '=') ? 2 : ((pToDecode[length - 1] == '=') ? 1 : 0);
 
  out.resize(outLength);
  unsigned char* data = (unsigned char*)out.asArrayPtr();
 
  for (OdUInt32 i = 0, j = 0; i < length;)
  {
    OdUInt32 sextet_a = (pToDecode[i] == '=') ? (0 & i++) : decode64Dict[pToDecode[i++]];
    OdUInt32 sextet_b = (pToDecode[i] == '=') ? (0 & i++) : decode64Dict[pToDecode[i++]];
    OdUInt32 sextet_c = (pToDecode[i] == '=') ? (0 & i++) : decode64Dict[pToDecode[i++]];
    OdUInt32 sextet_d = (pToDecode[i] == '=') ? (0 & i++) : decode64Dict[pToDecode[i++]];
 
    OdUInt32 triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6);
 
    if (j < outLength)
      data[j++] = (triple >> 2 * 8) & 0xFF;
    if (j < outLength)
      data[j++] = (triple >> 1 * 8) & 0xFF;
    if (j < outLength)
      data[j++] = (triple >> 0 * 8) & 0xFF;
  }
  return outLength;
}
 
inline OdString decodeBase64ToOdString(const char* data)
{
  OdAnsiString ansiStr(data);
  OdBinaryData out;
  decodeBase64(ansiStr, out);
  const OdUInt8* pBuff = out.asArrayPtr();
  return OdPlatformStreamer::getUnicodeStrFromBuffer(pBuff, out.size() / 2);
}
 
 
 
 
 
#endif