1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// File: LDOM_MemManager.hxx
// Created: 26.06.01 11:30:08
// Author: Alexander GRIGORIEV
// Copyright: OpenCascade 2001
#ifndef LDOM_MemManager_HeaderFile
#define LDOM_MemManager_HeaderFile
#include <MMgt_TShared.hxx>
#include <Standard_DefineHandle.hxx>
#include <LDOM_Document.hxx>
class LDOM_BasicElement;
// Class LDOM_MemManager (underlying structure of LDOM_Document)
//
class LDOM_MemManager : public MMgt_TShared
{
public:
// ---------- PUBLIC METHODS ----------
Standard_EXPORT LDOM_MemManager (const Standard_Integer aBlockSize);
// Constructor
Standard_EXPORT ~LDOM_MemManager ();
// Destructor
Standard_EXPORT void * Allocate (const Standard_Integer aSize);
// General Memory allocator
const char * HashedAllocate (const char * aString,
const Standard_Integer theLen,
Standard_Integer& theHash);
// Memory allocation with access via hash table. No new allocation
// if already present
void HashedAllocate (const char * aString,
const Standard_Integer theLen,
LDOMBasicString& theResult);
// Memory allocation with access via hash table. No new allocation
// if already present
static Standard_Integer Hash (const char * theString,
const Standard_Integer theLen)
{ return HashTable::Hash (theString, theLen); }
static Standard_Boolean CompareStrings(const char * theString,
const Standard_Integer theHashValue,
const char * theHashedStr);
LDOM_Document Doc () const
{ return LDOM_Document (* this); }
const LDOM_MemManager& Self () const
{ return * this; }
const LDOM_BasicElement * RootElement () const
{ return myRootElement; }
private:
friend class LDOM_Document;
friend class LDOMParser;
// ---- CLASS MemBlock ----
class MemBlock {
friend class LDOM_MemManager;
inline MemBlock (const Standard_Integer aSize, MemBlock * aFirst);
inline void * Allocate (const Standard_Integer aSize);
void * AllocateAndCheck (const Standard_Integer aSize, const MemBlock *&);
~MemBlock ();
MemBlock * Next () { return myNext; }
Standard_Integer mySize;
Standard_Integer * myBlock;
Standard_Integer * myEndBlock;
Standard_Integer * myFreeSpace;
MemBlock * myNext;
};
// ---- CLASS HashTable ----
class HashTable {
friend class LDOM_MemManager;
HashTable (/* const Standard_Integer theMask, */
LDOM_MemManager& theMemManager);
const char * AddString (const char * theString,
const Standard_Integer theLen,
Standard_Integer& theHashIndex);
static Standard_Integer Hash(const char * theString,
const Standard_Integer theLen);
// Note : This operator must be implemented on first use. It is currently defined to avoid compiler warnings
HashTable & operator = (const HashTable &) { return *this; }
struct TableItem {
char * str;
struct TableItem * next;
} * myTable;
// Standard_Integer myMask;
LDOM_MemManager& myManager;
};
// ---- PROHIBITED (PRIVATE) METHODS ----
LDOM_MemManager (const LDOM_MemManager& theOther);
// Copy constructor
LDOM_MemManager& operator = (const LDOM_MemManager& theOther);
// Assignment
// ---------- PRIVATE FIELDS ----------
const LDOM_BasicElement * myRootElement;
MemBlock * myFirstBlock;
MemBlock * myFirstWithoutRoom;
Standard_Integer myBlockSize;
HashTable * myHashTable;
public:
// CASCADE RTTI
DEFINE_STANDARD_RTTI (LDOM_MemManager)
};
#include <Handle_LDOM_MemManager.hxx>
#endif
|
