///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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-2016 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 __OdGsFilerV100Impl_H__
|
#define __OdGsFilerV100Impl_H__
|
|
#include "TD_PackPush.h"
|
#include "Ge/GeMatrix3d.h"
|
#include "Ge/GeExtents3d.h"
|
#include "DbBaseDatabase.h"
|
#include "GsFiler.h"
|
#include "OdStack.h"
|
#include "RxObjectImpl.h"
|
|
|
// Database linker
|
class OdGsFilerDbLinker : public OdRxObject
|
{
|
public:
|
OdGsFilerDbLinker() { }
|
virtual ~OdGsFilerDbLinker() { }
|
public:
|
// Get database hash
|
virtual OdBinaryData getDbHash(const OdDbBaseDatabase *pDb) const;
|
|
// Transform database handle
|
virtual OdUInt64 stubToDbHandle(OdDbStub *pStub) const = 0;
|
virtual OdDbStub *handleToDbStub(OdUInt64 nHandle) const = 0;
|
|
// Util methods
|
virtual OdDbBaseDatabase *getDatabase() const = 0;
|
virtual OdDbBaseDatabase *getDatabase(OdDbStub *pStub) const = 0;
|
};
|
|
typedef OdSmartPtr<OdGsFilerDbLinker> OdGsFilerDbLinkerPtr;
|
|
|
|
#define STL_USING_MAP
|
#define STL_USING_SET
|
#include "OdaSTL.h"
|
|
// Implement substitutor
|
struct GS_TOOLKIT_EXPORT OdGsFiler_SubstitutorImpl : public OdRxObject, public OdGsFiler::Substitutor
|
{
|
template<OdUInt32 nBytes> struct DataTyp
|
{
|
OdUInt8 m_data[nBytes];
|
static int compare(const DataTyp &t1, const DataTyp &t2)
|
{
|
for (OdUInt32 nb = 0; nb < nBytes; nb++)
|
{
|
if (t1.m_data[nb] != t2.m_data[nb])
|
return int(t1.m_data[nb]) - int(t2.m_data[nb]);
|
}
|
return 0;
|
}
|
bool operator ==(const DataTyp &t2) const { return compare(*this, t2) == 0; }
|
bool operator !=(const DataTyp &t2) const { return compare(*this, t2) != 0; }
|
bool operator <(const DataTyp &t2) const { return compare(*this, t2) < 0; }
|
bool operator <=(const DataTyp &t2) const { return compare(*this, t2) <= 0; }
|
bool operator >(const DataTyp &t2) const { return compare(*this, t2) > 0; }
|
bool operator >=(const DataTyp &t2) const { return compare(*this, t2) >= 0; }
|
|
operator const void*() const { return this; }
|
};
|
struct VoidsSet
|
{
|
void *m_pVoid;
|
OdGsFiler::SubstitutionActuator *m_pAct;
|
};
|
struct VoidArry : public VoidsSet
|
{
|
OdInt32 m_nVoids;
|
VoidArry()
|
: m_nVoids(0)
|
{
|
m_pVoid = NULL;
|
m_pAct = NULL;
|
}
|
~VoidArry() { clear(); }
|
VoidsSet *getSet() { return (VoidsSet*)m_pVoid; }
|
VoidsSet *at(OdInt32 n) {
|
if (m_nVoids == 1)
|
return this;
|
return getSet() + n;
|
}
|
bool contains(void *pVoid);
|
void add(void *pVoid, OdGsFiler::SubstitutionActuator *pAct);
|
void kill(void *pVoid);
|
void clear();
|
};
|
|
struct AbstractTyp
|
{
|
void *m_pContainer;
|
AbstractTyp() : m_pContainer(NULL) { }
|
};
|
typedef std::map<OdUInt32, AbstractTyp> RegsMap;
|
typedef std::map<OdUInt32, AbstractTyp> SubstsMap;
|
RegsMap m_regs;
|
SubstsMap m_substs;
|
|
template<OdUInt32 nBytes> struct Procs
|
{
|
typedef OdGsFiler_SubstitutorImpl::DataTyp<nBytes> ProcTyp;
|
typedef std::map<ProcTyp, ProcTyp> RegMap;
|
typedef std::map<ProcTyp, VoidArry> SubstMap;
|
static void makeSubst(void *pPlace, const void *pSubstitution)
|
{
|
*(ProcTyp*)(pPlace) = *(const ProcTyp*)(pSubstitution);
|
}
|
static void runSubst(void *pPlace, const void *pSubstitution, OdGsFiler::SubstitutionActuator *pActuator)
|
{
|
ODA_ASSERT(pActuator);
|
pActuator->applySubstitution(pPlace, pSubstitution, makeSubst);
|
}
|
static void subst(OdGsFiler_SubstitutorImpl &impl, const void *pValue, void *pPlace, OdGsFiler::SubstitutionActuator *pAct, const void *pSubstitution, bool bClear)
|
{
|
if (pPlace && pSubstitution)
|
{
|
runSubst(pPlace, pSubstitution, pAct);
|
return;
|
}
|
if (pValue)
|
{
|
if (pPlace)
|
{
|
RegMap *pRegMap = (RegMap*)impl.m_regs[nBytes].m_pContainer;
|
OD_TYPENAME RegMap::iterator itReg = pRegMap->find(*(const ProcTyp*)pValue);
|
if (itReg != pRegMap->end())
|
{
|
runSubst(pPlace, itReg->second, pAct);
|
if (bClear)
|
pRegMap->erase(itReg);
|
}
|
}
|
else if (pSubstitution)
|
{
|
SubstMap *pSubMap = (SubstMap*)impl.m_substs[nBytes].m_pContainer;
|
OD_TYPENAME SubstMap::iterator itSub = pSubMap->find(*(const ProcTyp*)pValue);
|
if (itSub != pSubMap->end())
|
{
|
for (OdInt32 n = 0; n < itSub->second.m_nVoids; n++)
|
runSubst(itSub->second.at(n)->m_pVoid, pSubstitution, itSub->second.at(n)->m_pAct);
|
if (bClear)
|
pSubMap->erase(itSub);
|
}
|
}
|
else
|
{
|
RegMap *pRegMap = (RegMap*)impl.m_regs[nBytes].m_pContainer;
|
SubstMap *pSubMap = (SubstMap*)impl.m_substs[nBytes].m_pContainer;
|
if (pRegMap && pSubMap)
|
{
|
OD_TYPENAME RegMap::iterator itReg = pRegMap->find(*(const ProcTyp*)pValue);
|
OD_TYPENAME SubstMap::iterator itSub = pSubMap->find(*(const ProcTyp*)pValue);
|
if ((itReg != pRegMap->end()) && (itSub != pSubMap->end()))
|
{
|
for (OdInt32 n = 0; n < itSub->second.m_nVoids; n++)
|
runSubst(itSub->second.at(n)->m_pVoid, itReg->second, itSub->second.at(n)->m_pAct);
|
}
|
if (bClear)
|
{
|
if (itReg != pRegMap->end())
|
pRegMap->erase(itReg);
|
if (itSub != pSubMap->end())
|
pSubMap->erase(itSub);
|
}
|
}
|
else if (bClear)
|
{
|
if (pRegMap)
|
{
|
OD_TYPENAME RegMap::iterator itReg = pRegMap->find(*(const ProcTyp*)pValue);
|
if (itReg != pRegMap->end())
|
pRegMap->erase(itReg);
|
}
|
if (pSubMap)
|
{
|
OD_TYPENAME SubstMap::iterator itSub = pSubMap->find(*(const ProcTyp*)pValue);
|
if (itSub != pSubMap->end())
|
pSubMap->erase(itSub);
|
}
|
}
|
}
|
return;
|
}
|
RegMap *pRegMap = (RegMap*)impl.m_regs[nBytes].m_pContainer;
|
SubstMap *pSubMap = (SubstMap*)impl.m_substs[nBytes].m_pContainer;
|
if (pRegMap && pSubMap)
|
{
|
OD_TYPENAME RegMap::iterator itReg = pRegMap->begin();
|
while (itReg != pRegMap->end())
|
{
|
OD_TYPENAME SubstMap::iterator itSub = pSubMap->find(itReg->first);
|
if (itSub != pSubMap->end())
|
{
|
for (OdInt32 n = 0; n < itSub->second.m_nVoids; n++)
|
runSubst(itSub->second.at(n)->m_pVoid, itReg->second, itSub->second.at(n)->m_pAct);
|
}
|
itReg++;
|
}
|
}
|
if (bClear)
|
{
|
if (pRegMap) { delete pRegMap; impl.m_regs[nBytes].m_pContainer = NULL; }
|
if (pSubMap) { delete pSubMap; impl.m_substs[nBytes].m_pContainer = NULL; }
|
}
|
}
|
static void reg(OdGsFiler_SubstitutorImpl &impl, const void *pValue, const void *pSubstitution, bool bRegister, bool bImmediate)
|
{
|
if (bRegister)
|
{
|
OdGsFiler_SubstitutorImpl::AbstractTyp &cont = impl.m_regs[nBytes];
|
if (!cont.m_pContainer)
|
cont.m_pContainer = new RegMap;
|
RegMap &pMap = *(RegMap*)cont.m_pContainer;
|
pMap[*(const ProcTyp*)pValue] = *(const ProcTyp*)pSubstitution;
|
}
|
if (bImmediate)
|
subst(impl, pValue, NULL, NULL, pSubstitution, false);
|
}
|
static void req(OdGsFiler_SubstitutorImpl &impl, void *pPlace, OdGsFiler::SubstitutionActuator *pAct, const void *pValue, bool bRegister, bool bImmediate)
|
{
|
if (bRegister)
|
{
|
if (bImmediate)
|
{
|
RegMap *pRegMap = (RegMap*)impl.m_regs[nBytes].m_pContainer;
|
if (pRegMap)
|
{
|
OD_TYPENAME RegMap::iterator itReg = pRegMap->find(*(const ProcTyp*)pValue);
|
if (itReg != pRegMap->end())
|
{
|
runSubst(pPlace, itReg->second, pAct);
|
return;
|
}
|
}
|
}
|
OdGsFiler_SubstitutorImpl::AbstractTyp &cont = impl.m_substs[nBytes];
|
if (!cont.m_pContainer)
|
cont.m_pContainer = new SubstMap;
|
SubstMap &pMap = *(SubstMap*)cont.m_pContainer;
|
pMap[*(const ProcTyp*)pValue].add(pPlace, pAct);
|
}
|
else if (bImmediate)
|
subst(impl, pValue, pPlace, pAct, NULL, false);
|
}
|
static void clear(OdGsFiler_SubstitutorImpl &impl, const void *pValue)
|
{
|
RegMap *pRegMap = (RegMap*)impl.m_regs[nBytes].m_pContainer;
|
SubstMap *pSubMap = (SubstMap*)impl.m_substs[nBytes].m_pContainer;
|
if (pValue)
|
{
|
if (pRegMap)
|
{
|
OD_TYPENAME RegMap::iterator it = pRegMap->find(*(const ProcTyp*)pValue);
|
if (it != pRegMap->end())
|
pRegMap->erase(it);
|
}
|
if (pSubMap)
|
{
|
OD_TYPENAME SubstMap::iterator it = pSubMap->find(*(const ProcTyp*)pValue);
|
if (it != pSubMap->end())
|
pSubMap->erase(it);
|
}
|
}
|
else
|
{
|
if (pRegMap) { delete pRegMap; impl.m_regs[nBytes].m_pContainer = NULL; }
|
if (pSubMap) { delete pSubMap; impl.m_substs[nBytes].m_pContainer = NULL; }
|
}
|
}
|
};
|
|
static OdGsFiler::SubstitutionActuator g_defActuator;
|
static struct OdRxObjectSubstitutionActuator : public OdGsFiler::SubstitutionActuator
|
{
|
OdRxObjectSubstitutionActuator() { }
|
virtual void applySubstitution(void *pPlace, const void *pValue, SetPtrFunc pSetFunc)
|
{
|
OdGsFiler::SubstitutionActuator::applySubstitution(pPlace, pValue, pSetFunc);
|
if (pPlace)
|
(*reinterpret_cast<OdRxObjectPtr*>(pPlace))->addRef();
|
}
|
} g_rxObjectActuator;
|
|
// Register known substitution
|
virtual void registerSubstitution(const void *pValue, const void *pSubstitution, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = false);
|
// Register substitution request
|
virtual void requestSubstitution(void *pPlace, const void *pValue, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = true);
|
// Register substitution request for smart pointer
|
virtual void requestSubstitution(OdBaseObjectPtr *pPlace, const void *pValue, bool bRegister = true, bool bImmediate = true);
|
// Register substitution with non-default behavior
|
virtual void requestSubstitution(void *pPlace, OdGsFiler::SubstitutionActuator *pActuator, const void *pValue, OdUInt32 size = sizeof(OdIntPtr), bool bRegister = true, bool bImmediate = true);
|
// Clear substitutions
|
virtual void clearSubstitutions(const void *pValue = NULL, OdUInt32 size = 0);
|
// Run substitutions
|
virtual void runSubstitutions(const void *pValue = NULL, OdUInt32 size = 0, bool bClear = true);
|
#undef REG_FUNCCALL
|
~OdGsFiler_SubstitutorImpl() { clearSubstitutions(); }
|
};
|
|
|
// Implement V1 version filer
|
class GS_TOOLKIT_EXPORT OdGsFilerV100Impl : public OdGsFiler {
|
protected:
|
enum Flags {
|
kOpenedForWrite = (1 << 0),
|
|
kLastFlag = kOpenedForWrite
|
};
|
protected:
|
mutable OdStreamBufPtr m_pStream;
|
OdGsFilerDbLinkerPtr m_pLinker;
|
OdUInt64 m_nSectionsToWrite;
|
OdUInt64 m_nSectionsToRead;
|
OdUInt32 m_nFlags;
|
OdUInt32 m_nVersion;
|
mutable Section m_nCurSection;
|
mutable OdUInt32 m_nCurSectionSize;
|
struct WrSectionData {
|
OdGsFiler::Section m_type;
|
OdUInt64 m_begin;
|
WrSectionData()
|
: m_type(OdGsFiler::kEOFSection)
|
, m_begin(0)
|
{ }
|
WrSectionData(OdGsFiler::Section section, OdUInt32 tell)
|
: m_type(section)
|
, m_begin(tell)
|
{ }
|
};
|
OdStack<WrSectionData> m_sectionStack;
|
mutable OdSmartPtr<OdGsFiler_SubstitutorImpl> m_subst;
|
typedef std::map<OdString, OdRxObjectPtr> ArbDataMap;
|
ArbDataMap m_arbData;
|
typedef std::set<const void *> RegPtrsSet;
|
RegPtrsSet m_regPtrs;
|
protected:
|
bool isWriting() const { return GETBIT(m_nFlags, kOpenedForWrite); }
|
void setWriting(bool bSet) { SETBIT(m_nFlags, kOpenedForWrite, bSet); }
|
|
void assertWr() const { if (!isWriting()) throw OdError(eNotOpenForWrite); }
|
void assertRd() const { if (isWriting()) throw OdError(eNotOpenForRead); }
|
public:
|
OdGsFilerV100Impl()
|
: m_nSectionsToWrite(OdUInt64(-1))
|
, m_nSectionsToRead(OdUInt64(-1))
|
, m_nFlags(0)
|
, m_nVersion(kV2)
|
, m_nCurSection(kEOFSection)
|
, m_nCurSectionSize(0)
|
{
|
m_subst = OdRxObjectImpl<OdGsFiler_SubstitutorImpl>::createObject();
|
}
|
~OdGsFilerV100Impl()
|
{
|
}
|
|
OdUInt32 headerTestChunk() const;
|
bool rdHeaderSection();
|
void wrHeaderSection();
|
|
virtual bool setStream(OdStreamBuf *pStream, bool bWrite = false);
|
virtual OdStreamBufPtr getStream() const;
|
|
virtual void setDatabase(const OdDbBaseDatabase *pDb);
|
virtual OdDbBaseDatabase *getDatabase() const;
|
|
virtual void setVersion(OdUInt32 nVersion);
|
virtual OdUInt32 version() const;
|
|
virtual void wrDbHash(const OdDbBaseDatabase *pDb);
|
virtual bool checkDbHash(const OdDbBaseDatabase *pDb);
|
|
virtual void setWriteSections(OdUInt64 nSections);
|
virtual void setWriteSection(Section section, bool bSet);
|
virtual bool isWriteSection(Section section) const;
|
|
virtual void setReadSections(OdUInt64 nSections);
|
virtual void setReadSection(Section section, bool bSet);
|
virtual bool isReadSection(Section section) const;
|
|
virtual void wrSectionBegin(Section section);
|
virtual void wrSectionEnd(Section section);
|
virtual void wrEOFSection();
|
|
virtual Section rdSection() const;
|
virtual Section curSection() const;
|
virtual void skipSection() const;
|
virtual void rdBackSection() const;
|
virtual bool checkEOF() const;
|
|
virtual Substitutor *subst() const;
|
virtual void makeSubstitutions(bool bClear = true) const;
|
virtual OdRxObjectPtr getSubstitutor() const;
|
virtual void setSubstitutor(OdRxObject *pSubst);
|
|
virtual void setArbitraryData(const OdChar *pName, OdRxObject *pObject);
|
virtual OdRxObjectPtr getArbitraryData(const OdChar *pName) const;
|
virtual bool hasArbitraryData(const OdChar *pName) const;
|
virtual void clearArbitraryData();
|
|
virtual void registerPtr(const void *pPtr);
|
virtual void unregisterPtr(const void *pPtr);
|
virtual bool isPtrRegistered(const void *pPtr) const;
|
virtual void clearRegisteredPtrs();
|
|
virtual void wrHandle(OdDbStub *pHandle);
|
virtual OdDbStub *rdHandle() const;
|
|
virtual void wrClass(OdRxObject *pObj);
|
virtual OdRxObjectPtr rdClass() const;
|
|
virtual void wrRawData(const void *pData, OdUInt32 nDataSize);
|
virtual void rdRawData(void *pData, OdUInt32 nDataSize) const;
|
};
|
|
#include "TD_PackPop.h"
|
|
#endif // __OdGsFilerV100Impl_H__
|
