source: icXML/icXML-devel/src/icxercesc/util/QName.cpp

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

Changes to icxercesc files

File size: 7.7 KB
Line 
1/*
2 * Unless required by applicable law or agreed to in writing, software
3 * distributed under the License is distributed on an "AS IS" BASIS,
4 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
5 * See the License for the specific language governing permissions and
6 * limitations under the License.
7 */
8
9/*
10 * $Id: QName.cpp 810580 2009-09-02 15:52:22Z amassari $
11 */
12
13#include <xercesc/util/Janitor.hpp>
14#include <icxercesc/util/QName.hpp>
15#include <xercesc/util/OutOfMemoryException.hpp>
16#include <icxercesc/framework/XMLBuffer.hpp>
17#include <icxmlc/XMLNamespaceResolver.hpp>
18#include <icxmlc/XMLConfig.hpp>
19
20XERCES_CPP_NAMESPACE_BEGIN
21
22typedef JanitorMemFunCall<QName>    CleanupType;
23
24// ---------------------------------------------------------------------------
25//  QName: Constructors and Destructor
26// ---------------------------------------------------------------------------
27QName::QName(XMLStringPool* const stringPool)
28: fURIId(XMLNamespaceResolver::fEmptyUriId)
29, fPrefix(0)
30, fLocalPart(0)
31, fRawName(0)
32, fStringPool(stringPool)
33{
34
35}
36
37QName::QName
38(
39      const XMLCh* const        prefix
40    , const XMLCh* const        localPart
41    , const unsigned int        uriId
42    , XMLStringPool * const     stringPool
43)
44: fURIId(XMLNamespaceResolver::fEmptyUriId)
45, fPrefix(0)
46, fLocalPart(0)
47, fRawName(0)
48, fStringPool(stringPool)
49{
50        CleanupType cleanup(this, &QName::cleanUp);
51
52    assert (stringPool);
53
54        try
55        {
56                //
57                //  Just call the local setters to set up everything. Too much
58                //  work is required to replicate that functionality here.
59                //
60                setName(prefix, localPart, uriId);
61        }
62        catch(const OutOfMemoryException&)
63        {
64                cleanup.release();
65                throw;
66        }
67
68        cleanup.release();
69}
70
71QName::QName
72(
73      const XMLCh* const    rawName
74    , const unsigned int    uriId
75    , XMLStringPool * const stringPool
76)
77: fURIId(XMLNamespaceResolver::fEmptyUriId)
78, fPrefix(0)
79, fLocalPart(0)
80, fRawName(0)
81, fStringPool(stringPool)
82{
83        CleanupType cleanup(this, &QName::cleanUp);
84
85    assert (stringPool);
86
87        try
88        {
89                //
90                //  Just call the local setters to set up everything. Too much
91                //  work is required to replicate that functionality here.
92                //
93                setName(rawName, uriId);
94        }
95        catch(const OutOfMemoryException&)
96        {
97                cleanup.release();
98
99                throw;
100        }
101
102        cleanup.release();
103}
104
105/** Constructs a specified qname using prefix, and localpart. */
106QName::QName
107(
108      const XMLCh* const    rawName
109    , const int             colonInd
110    , const unsigned int    uriId
111    , XMLStringPool * const stringPool
112)
113: fURIId(XMLNamespaceResolver::fEmptyUriId)
114, fPrefix(0)
115, fLocalPart(0)
116, fRawName(0)
117, fStringPool(stringPool)
118{
119        CleanupType cleanup(this, &QName::cleanUp);
120
121        try
122        {
123                //
124                //  Just call the local setters to set up everything. Too much
125                //  work is required to replicate that functionality here.
126                //
127                setName(rawName, colonInd, uriId);
128        }
129        catch (const OutOfMemoryException&)
130        {
131                cleanup.release();
132                throw;
133        }
134
135        cleanup.release();
136}
137
138QName::~QName()
139{
140        cleanUp();
141}
142
143// ---------------------------------------------------------------------------
144//  QName: Copy Constructors
145// ---------------------------------------------------------------------------
146QName::QName(const QName & qName)
147: XSerializable(qName)
148, XMemory(qName)
149, fURIId(qName.fURIId)
150, fPrefix(qName.fPrefix)
151, fLocalPart(qName.fLocalPart)
152, fRawName(qName.fRawName)
153, fStringPool(qName.fStringPool)
154{
155
156}
157
158QName & QName::operator=(const QName & qName)
159{
160    // free up the original memory if need be
161    cleanUp();
162    // and 'clone' the supplied QName
163    fURIId = qName.fURIId;
164    fPrefix = qName.fPrefix;
165    fLocalPart = qName.fLocalPart;
166    fRawName = qName.fRawName;
167    fStringPool = qName.fStringPool;
168    return *this;
169}
170
171// ---------------------------------------------------------------------------
172//  QName: Setter methods
173// ---------------------------------------------------------------------------
174
175void QName::setName
176(
177    const XMLCh* const      rawName
178    , const int             colonInd
179    , const unsigned int    uriId
180)
181{
182    fRawName = getInternedValue(rawName);
183        if (colonInd == -1)
184        {               
185        fPrefix = getInternedValue(XMLUni::fgZeroLenString);
186        fLocalPart = fRawName;
187        }
188        else
189        {
190        const_cast<XMLCh*>(rawName)[colonInd] = chNull;
191        fPrefix = getInternedValue(rawName);
192        fLocalPart = getInternedValue(&rawName[colonInd + 1]);
193        const_cast<XMLCh*>(rawName)[colonInd] = chColon;
194        }
195
196    // And finally store the URI id parameter
197        fURIId = uriId;
198}
199
200
201void QName::setName
202(
203    const XMLCh* const      prefix
204    , const XMLCh* const    localPart
205    , const unsigned int    uriId
206)
207{
208    fLocalPart = getInternedValue(localPart);
209    if (prefix && *prefix)
210        {
211        fPrefix = getInternedValue(prefix);
212        XMLBuffer rawName(126, getMemoryManager());
213        rawName.set(prefix);
214        rawName.append(chColon);
215        rawName.append(localPart);
216        fRawName = getInternedValue(rawName.getRawBuffer());
217        }
218        else
219        {
220        fPrefix = getInternedValue(XMLUni::fgZeroLenString);
221        fRawName = fLocalPart;
222        }
223
224    // And finally store the URI id parameter
225        fURIId = uriId;
226}
227
228void QName::setName(const XMLCh* const rawName, const unsigned int uriId)
229{
230    setName(rawName, XMLString::indexOf(rawName, chColon), uriId);
231}
232
233void QName::setNPrefix(const XMLCh* prefix, const XMLSize_t newLen)
234{
235        setName(prefix, this->fLocalPart, this->fURIId);
236}
237
238void QName::setNLocalPart(const XMLCh* localPart, const XMLSize_t newLen)
239{
240        setName(this->fPrefix, localPart, this->fURIId);
241}
242
243void QName::setValues(const QName & qName)
244{
245    *this = qName;
246}
247
248// -----------------------------------------------------------------------
249//  getters
250// -----------------------------------------------------------------------
251const XMLCh* QName::getRawName() const
252{
253    return fRawName;
254}
255
256XMLCh* QName::getRawName()
257{
258    return fRawName;
259}
260
261// -----------------------------------------------------------------------
262//  comparison
263// -----------------------------------------------------------------------
264bool QName::operator==(const QName& qname) const
265{
266    if (unlikely(getURI() == XMLNamespaceResolver::fUnknownUriId))
267    {
268        if (getRawName() == qname.getRawName())
269        {
270            return true;
271        }
272        #ifdef PRINT_DEBUG_MESSAGE
273        else
274        {
275            assert(XMLString::compareString(getRawName(), qname.getRawName()) != 0);
276        }
277        #endif
278    }
279    else if (getURI() == qname.getURI())
280    {
281        if (getLocalPart() == qname.getLocalPart())
282        {
283            return true;
284        }
285        #ifdef PRINT_DEBUG_MESSAGE
286        else
287        {
288            assert(XMLString::compareString(getLocalPart(), qname.getLocalPart()) != 0);
289        }
290        #endif
291    }
292    return true;
293}
294
295// ---------------------------------------------------------------------------
296//  QName: Private, helper methods
297// ---------------------------------------------------------------------------
298
299void QName::cleanUp()
300{
301
302}
303
304/***
305 * Support for Serialization/De-serialization
306 ***/
307IMPL_XSERIALIZABLE_TOCREATE(QName)
308
309void QName::serialize(XSerializeEngine&)
310{
311    DEPRECATED_FEATURE_IN_ICXML;
312}
313
314QName::QName(MemoryManager* const)
315{
316    DEPRECATED_FEATURE_IN_ICXML;
317}
318
319QName::QName
320(
321      const XMLCh* const   prefix
322    , const XMLCh* const   localPart
323    , const unsigned int   uriId
324    , MemoryManager* const manager
325)
326{
327    DEPRECATED_FEATURE_IN_ICXML;
328}
329
330QName::QName
331(
332      const XMLCh* const   rawName
333    , const unsigned int   uriId
334    , MemoryManager* const manager
335)
336{
337    DEPRECATED_FEATURE_IN_ICXML;
338}
339
340/** Constructs a specified qname using prefix, and localpart. */
341QName::QName
342(
343      const XMLCh* const   rawName
344    , const int            colonInd
345    , const unsigned int   uriId
346    , MemoryManager* const manager
347)
348{
349    DEPRECATED_FEATURE_IN_ICXML;
350}
351
352
353XERCES_CPP_NAMESPACE_END
Note: See TracBrowser for help on using the repository browser.