source: icXML/icXML-devel/src/icxmlc/XMLNamespaceUriTable.hpp @ 2720

Last change on this file since 2720 was 2720, checked in by cameron, 6 years ago

Initial check-in of icXML 0.8 source files

File size: 3.9 KB
Line 
1#ifndef XMLNAMESPACEURITABLE_HPP
2#define XMLNAMESPACEURITABLE_HPP
3
4/*
5 *  Copyright © 2012 International Characters.
6 *  This software is licensed to the public under the Open Software License 3.0.
7 *  icXML is a trademark of International Characters.
8 */
9
10#include <icxmlc/HashTable.hpp>
11#include <icxmlc/stringpool.h>
12#include <icxmlc/XMLStringU.hpp>
13#include <xercesc/util/XMLUni.hpp>
14#include <xercesc/validators/common/Grammar.hpp>
15#include <xercesc/framework/MemoryManager.hpp>
16#include <icxmlc/XMLConfig.hpp>
17
18XERCES_CPP_NAMESPACE_BEGIN
19
20class XMLNamespaceTable;
21class XMLGlobalNamespaceTable;
22class XMLNamespaceResolver;
23
24/** ---------------------------------------------------------------------------------------------------------
25
26
27** --------------------------------------------------------------------------------------------------------- **/
28class XMLNamespaceEntry
29{
30        friend class XMLNamespaceTable;
31        friend class XMLGlobalNamespaceTable;
32        friend class XMLNamespaceResolver;
33
34        public:
35
36                XMLNamespaceEntry()
37                : fId(0)
38                , fKey(NULL)
39                , fLength(0)
40                {
41
42                }
43
44                XMLNamespaceEntry(const gid_t id, const XMLCh * key, unsigned int length)
45                : fId(id)
46                , fKey(key)
47                , fLength(length)
48                {
49
50                }
51
52                const XMLCh * getKey() const { return fKey; }
53
54                unsigned int getLength() const { return fLength; }
55
56                unsigned int getId() const { return fId; }
57
58                XMLNamespaceEntry & operator=(const XMLNamespaceEntry & other)
59                {
60                        fKey = other.fKey;
61                        fLength = other.fLength;
62                        fId = other.fId;
63                        return *this;
64                }
65
66                IDISA_ALWAYS_INLINE
67                bool equals(const XMLCh * otherKey, const unsigned int length) const
68                {
69                        return (getLength() == length) && (XMLStringU::equals(getKey(), otherKey, length));
70                }
71
72        protected:
73
74                gid_t                   fId;
75                const XMLCh *   fKey;
76                unsigned int    fLength;
77
78};
79
80/// ---------------------------------------------------------------------------------------------------------
81
82class XMLNamespaceTable
83{
84        friend class XMLGlobalNamespaceTable;
85
86        public:
87
88                XMLNamespaceTable(MemoryManager *)
89                {
90
91                }
92
93                IDISA_ALWAYS_INLINE
94                const XMLNamespaceEntry * operator[](const size_t id) const
95                {
96                        return fHashTable[id];
97                }
98
99                IDISA_ALWAYS_INLINE
100                unsigned int find(const XMLCh * string, const size_t length) const
101                {
102                        return fHashTable.find(string, length);
103                }
104
105                IDISA_ALWAYS_INLINE
106                size_t count() const
107                {
108                        return fHashTable.count();
109                }
110
111        protected:
112
113                IDISA_ALWAYS_INLINE
114                unsigned int add(const unsigned int localId, const unsigned int globalId, const XMLCh * string, const size_t length)
115                {
116                        XMLNamespaceEntry entry(globalId, string, length);
117                        return fHashTable.add(entry, localId);
118                }
119
120        private:
121
122                HashTable<XMLNamespaceEntry, XMLCh, sizeof(hash_t) * 16, 1>                     fHashTable;
123
124};
125
126/// ---------------------------------------------------------------------------------------------------------
127
128class XMLGlobalNamespaceTable
129{
130        public:
131
132                XMLGlobalNamespaceTable(MemoryManager * manager)
133                : fStringPool(manager)
134                {
135
136                }
137
138                IDISA_ALWAYS_INLINE
139                const XMLNamespaceEntry * operator[](const size_t id) const
140                {
141                        return fHashTable[id];
142                }
143
144                IDISA_ALWAYS_INLINE
145                unsigned int addOrFind(const unsigned int localId, const XMLCh * string, const size_t length, XMLNamespaceTable & localTable)
146                {
147                        unsigned int globalId = fHashTable.find(string, length);
148                        const XMLCh * key;
149                        if (globalId == -1)
150                        {
151                                key = fStringPool.insert(string, length);
152                                XMLNamespaceEntry entry(count(), key, length);
153                                globalId = fHashTable.add(entry);
154                        }
155                        else
156                        {
157                                // reuse the global pool string memory for the local key
158                                key = fHashTable[globalId]->getKey();
159                        }
160                        localTable.add(localId, globalId, key, length);
161                        return globalId;
162                }
163
164                IDISA_ALWAYS_INLINE
165                size_t count() const
166                {
167                        return fHashTable.count();
168                }
169
170        private:
171
172        HashTable<XMLNamespaceEntry, XMLCh, sizeof(hash_t) * 16, 0>                     fHashTable;
173                StringPool<XMLCh, INITIAL_NAMESPACE_RESOLVER_STRING_POOL_SIZE>          fStringPool;
174};
175
176XERCES_CPP_NAMESPACE_END
177
178#endif // XMLNAMESPACEURITABLE_HPP
Note: See TracBrowser for help on using the repository browser.