source: icXML/icXML-devel/src/icxercesc/util/TransService.hpp @ 2721

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

Fix imports in icXML modified Xerces files

File size: 25.7 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: TransService.hpp 932887 2010-04-11 13:04:59Z borisk $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_TRANSSERVICE_HPP)
23#define XERCESC_INCLUDE_GUARD_TRANSSERVICE_HPP
24
25#include <xercesc/util/XMemory.hpp>
26#include <xercesc/util/XAlignedMemory.hpp>
27#include <icxercesc/framework/XMLBuffer.hpp>
28#include <icxercesc/util/PlatformUtils.hpp>
29#include <icxercesc/framework/XMLRecognizer.hpp>
30#include <icxercesc/util/RefHashTableOf.hpp>
31#include <xercesc/util/RefVectorOf.hpp>
32#include <icxmlc/XMLLineColTracker.hpp>
33#include <icxmlc/XMLParserDefs.hpp>
34
35XERCES_CPP_NAMESPACE_BEGIN
36
37// Forward references
38class XMLLCPTranscoder;
39class XMLTranscoder;
40class ENameMap;
41class XMLScanner;
42class XMLLineColTracker;
43class XMLSymbolTable;
44
45//
46//  This class is an abstract base class which are used to abstract the
47//  transcoding services that Xerces uses. The parser's actual transcoding
48//  needs are small so it is desirable to allow different implementations
49//  to be provided.
50//
51//  The transcoding service has to provide a couple of required string
52//  and character operations, but its most important service is the creation
53//  of transcoder objects. There are two types of transcoders, which are
54//  discussed below in the XMLTranscoder class' description.
55//
56class XMLUTIL_EXPORT XMLTransService : public XMemory
57{
58public :
59        // -----------------------------------------------------------------------
60        //  Class specific types
61        // -----------------------------------------------------------------------
62        enum Codes
63        {
64                Ok
65                , UnsupportedEncoding
66                , InternalFailure
67                , SupportFilesNotFound
68        };
69
70        struct TransRec
71        {
72                XMLCh       intCh;
73                XMLByte     extCh;
74        };
75
76
77        // -----------------------------------------------------------------------
78        //  Public constructors and destructor
79        // -----------------------------------------------------------------------
80        virtual ~XMLTransService();
81
82
83        // -----------------------------------------------------------------------
84        //  Non-virtual API
85        // -----------------------------------------------------------------------
86
87        XMLTranscoder* makeNewTranscoderFor
88        (
89                const   XMLCh* const            encodingName
90                ,       XMLTransService::Codes& resValue
91                , const XMLSize_t               blockSize
92                , MemoryManager* const          manager = XMLPlatformUtils::fgMemoryManager
93        );
94
95        XMLTranscoder* makeNewTranscoderFor
96        (
97                const   char* const             encodingName
98                ,       XMLTransService::Codes& resValue
99                , const XMLSize_t               blockSize
100                , MemoryManager* const          manager = XMLPlatformUtils::fgMemoryManager
101        );
102
103        XMLTranscoder* makeNewTranscoderFor
104        (
105                XMLRecognizer::Encodings        encodingEnum
106                ,       XMLTransService::Codes& resValue
107                , const XMLSize_t               blockSize
108                , MemoryManager* const          manager = XMLPlatformUtils::fgMemoryManager
109        );
110
111        // -----------------------------------------------------------------------
112        //  The virtual transcoding service API
113        // -----------------------------------------------------------------------
114        virtual int compareIString
115        (
116                const   XMLCh* const    comp1
117                , const XMLCh* const    comp2
118        ) = 0;
119
120        virtual int compareNIString
121        (
122                const   XMLCh* const    comp1
123                , const XMLCh* const    comp2
124                , const XMLSize_t       maxChars
125        ) = 0;
126
127        virtual const XMLCh* getId() const = 0;
128
129        // -----------------------------------------------------------------------
130        //      Create a new transcoder for the local code page.
131        //
132        //  @param manager The memory manager to use.
133        // -----------------------------------------------------------------------
134        virtual XMLLCPTranscoder* makeNewLCPTranscoder(MemoryManager* manager) = 0;
135
136        virtual bool supportsSrcOfs() const = 0;
137
138        virtual void upperCase(XMLCh* const toUpperCase) = 0;
139        virtual void lowerCase(XMLCh* const toLowerCase) = 0;
140
141        // -----------------------------------------------------------------------
142        //      Allow users to add their own encodings to the intrinsic mapping
143        //      table
144        //      Usage:
145        //              XMLTransService::addEncoding (
146        //                      gMyEncodingNameString
147        //                      , new ENameMapFor<MyTransClassType>(gMyEncodingNameString)
148        //              );
149        // -----------------------------------------------------------------------
150        static void addEncoding(const XMLCh* const encoding, ENameMap* const ownMapping);
151
152
153protected :
154        // -----------------------------------------------------------------------
155        //  Hidden constructors
156        // -----------------------------------------------------------------------
157        XMLTransService();
158
159
160        // -----------------------------------------------------------------------
161        //  Protected virtual methods.
162        // -----------------------------------------------------------------------
163#ifdef OS390
164        friend class Uniconv390TransService;
165#endif
166        virtual XMLTranscoder* makeNewXMLTranscoder
167        (
168                const   XMLCh* const            encodingName
169                ,       XMLTransService::Codes& resValue
170                , const XMLSize_t               blockSize
171                , MemoryManager* const          manager
172        ) = 0;
173
174        // -----------------------------------------------------------------------
175        //  Protected init method for platform utils to call
176        // -----------------------------------------------------------------------
177        friend class XMLPlatformUtils;
178        virtual void initTransService();
179
180        // -----------------------------------------------------------------------
181        // protected static members
182        //  gMappings
183        //      This is a hash table of ENameMap objects. It is created and filled
184        //      in when the platform init calls our initTransService() method.
185        //
186        //  gMappingsRecognizer
187        //      This is an array of ENameMap objects, predefined for those
188        //      already recognized by XMLRecognizer::Encodings.
189        //
190
191        static RefHashTableOf<ENameMap>*    gMappings;
192        static RefVectorOf<ENameMap>*       gMappingsRecognizer;
193
194private :
195        // -----------------------------------------------------------------------
196        //  Unimplemented constructors and operators
197        // -----------------------------------------------------------------------
198        XMLTransService(const XMLTransService&);
199        XMLTransService& operator=(const XMLTransService&);
200
201        // -----------------------------------------------------------------------
202        //  Hidden method to enable/disable strict IANA encoding check
203        //  Caller: XMLPlatformUtils
204        // -----------------------------------------------------------------------
205        void strictIANAEncoding(const bool newState);
206        bool isStrictIANAEncoding();
207
208        friend class XMLInitializer;
209};
210
211/**
212  *   <code>XMLTranscoder</code> is for transcoding non-local code
213  *   page encodings, i.e.  named encodings. These are used internally
214  *   by the scanner to internalize raw XML into the internal Unicode
215  *   format, and by writer classes to convert that internal Unicode
216  *   format (which comes out of the parser) back out to a format that
217  *   the receiving client code wants to use.
218  */
219class XMLUTIL_EXPORT XMLTranscoder : public XMemory
220{
221public :
222
223                /**
224                 * This enum is used by the <code>transcodeTo()</code> method
225                 * to indicate how to react to unrepresentable characters. The
226                 * <code>transcodeFrom()</code> method always works the
227                 * same. It will consider any invalid data to be an error and
228                 * throw.
229                 */
230        enum UnRepOpts
231        {
232                UnRep_Throw             /**< Throw an exception */
233                , UnRep_RepChar         /**< Use the replacement char */
234        };
235
236
237                /** @name Destructor. */
238                //@{
239
240                 /**
241                  * Destructor for XMLTranscoder
242                  *
243                  */
244        virtual ~XMLTranscoder();
245                //@}
246
247
248
249        /** @name The virtual transcoding interface */
250        //@{
251
252        /** Converts from the encoding of the service to the internal XMLCh* encoding
253          *
254          * @param srcData the source buffer to be transcoded
255          * @param srcCount number of bytes in the source buffer
256          * @param toFill the destination buffer
257          * @param maxChars the max number of characters in the destination buffer
258          * @param bytesEaten after transcoding, this will hold the number of bytes
259          *    that were processed from the source buffer
260          * @param charSizes an array which must be at least as big as maxChars
261          *    into which will be inserted values that indicate how many
262          *    bytes from the input went into each XMLCh that was created
263          *    into toFill. Since many encodings use variable numbers of
264          *    byte per character, this provides a means to find out what
265          *    bytes in the input went into making a particular output
266          *    UTF-16 character.
267          * @return Returns the number of chars put into the target buffer
268          */
269        virtual XMLSize_t transcodeFrom
270        (
271                const   XMLByte* const          srcData
272                , const XMLSize_t               srcCount
273                ,       XMLCh* const            toFill
274                , const XMLSize_t               maxChars
275                ,       XMLSize_t&              bytesEaten
276                ,       unsigned char* const    charSizes
277        ) = 0;
278
279    /** Converts from the encoding of the service to the internal XMLCh* encoding
280      *
281      * @param srcData the source buffer to be transcoded
282      * @param srcCount number of bytes in the source buffer
283      * @param toFill the destination XMLBuffer
284      * @return Returns the number of chars put into the target buffer
285      */
286        virtual XMLSize_t transcodeFrom
287        (
288                  const XMLByte* const          srcData
289                , const XMLSize_t               srcCount
290                ,       XMLBuffer &             toFill
291    ) = 0;
292
293        /** Converts from the internal XMLCh* encoding to the encoding of the service
294          *
295          * @param srcData    the source buffer to be transcoded
296          * @param srcCount   number of characters in the source buffer
297          * @param toFill     the destination buffer
298          * @param maxBytes   the max number of bytes in the destination buffer
299          * @param charsEaten after transcoding, this will hold the number of chars
300          *    that were processed from the source buffer
301          * @param options    options to pass to the transcoder that explain how to
302          *    respond to an unrepresentable character
303          * @return Returns the number of chars put into the target buffer
304          */
305
306        virtual XMLSize_t transcodeTo
307        (
308                const   XMLCh* const    srcData
309                , const XMLSize_t       srcCount
310                ,       XMLByte* const  toFill
311                , const XMLSize_t       maxBytes
312                ,       XMLSize_t&      charsEaten
313                , const UnRepOpts       options
314        ) = 0;
315
316        /** Query whether the transcoder can handle a given character
317          *
318          * @param toCheck   the character code point to check
319          */
320
321        virtual bool canTranscodeTo
322        (
323                const   unsigned int    toCheck
324        ) = 0;
325
326        //@}
327
328        /** @name Getter methods */
329        //@{
330
331        /** Get the internal block size
332         *
333           * @return The block size indicated in the constructor.
334           */
335        XMLSize_t getBlockSize() const;
336
337        /** Get the encoding name
338          *
339          * @return the name of the encoding that this
340          *    <code>XMLTranscoder</code> object is for
341          */
342        const XMLCh* getEncodingName() const;
343                //@}
344
345        /** @name Getter methods*/
346        //@{
347
348        /** Get the plugged-in memory manager
349          *
350          * This method returns the plugged-in memory manager user for dynamic
351          * memory allocation/deallocation.
352          *
353          * @return the plugged-in memory manager
354          */
355        MemoryManager* getMemoryManager() const;
356
357
358    /** Get the plugged-in memory manager
359      *
360      * Returns whether the endianness of the character set encoding is swapped
361      * with respect to the endianness of the current architecture.
362      *
363      * @return true/false
364      */
365    virtual bool isSwapped() const;
366
367                //@}
368
369protected :
370        // -----------------------------------------------------------------------
371        //  Hidden constructors
372        // -----------------------------------------------------------------------
373        XMLTranscoder
374        (
375                const   XMLCh* const    encodingName
376                , const XMLSize_t       blockSize
377                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
378        );
379
380
381        // -----------------------------------------------------------------------
382        //  Protected helper methods
383        // -----------------------------------------------------------------------
384
385private :
386        // -----------------------------------------------------------------------
387        //  Unimplemented constructors and operators
388        // -----------------------------------------------------------------------
389        XMLTranscoder(const XMLTranscoder&);
390        XMLTranscoder& operator=(const XMLTranscoder&);
391
392        // -----------------------------------------------------------------------
393        //  Private data members
394        //
395        //  fBlockSize
396        //      This is the block size indicated in the constructor.
397        //
398        //  fEncodingName
399        //      This is the name of the encoding this encoder is for. All basic
400        //      XML transcoder's are for named encodings.
401        // -----------------------------------------------------------------------
402        XMLSize_t       fBlockSize;
403        XMLCh*          fEncodingName;
404        MemoryManager*  fMemoryManager;
405};
406
407class XMLCharacterSetAdapter
408{
409        public:
410                // -----------------------------------------------------------------------
411                //  Public constructors and destructor
412                // -----------------------------------------------------------------------
413                XMLCharacterSetAdapter(MemoryManager * manager)
414                : fSymbolTable(0)
415                , fInternalLineColTracker()
416                , fScanner(0)
417                , fMemoryManager(manager)
418                {
419
420                }
421
422                virtual ~XMLCharacterSetAdapter() = 0;
423
424                inline void init
425                (
426                        XMLScanner *                            scanner
427                        , XMLSymbolTable *                      symbolTable
428                        , const XMLLineColTracker & tracker
429                )
430                {
431                        fScanner = scanner;
432                        fSymbolTable = symbolTable;
433                        fInternalLineColTracker = tracker;
434                }
435
436                virtual XMLSize_t getCodeUnitSize() = 0;
437
438                virtual XMLCh * parse
439                (
440                        const XMLByte * const           src
441                        , const XMLSize_t                       offset
442                        , const XMLSize_t                       avail
443                        , const bool                            noMore
444                        ,       ContentStream &         contentStream
445                        ,           XMLSize_t                   contentOffset
446                        ,       unsigned int &          markupCount
447                        ,               SymbolArray &           symbolArray
448                        ,               unsigned int &          symbolCount
449                        ,               StringPtrArray &        stringEndArray
450                        ,       unsigned int &          stringEndCount
451                        ,       XMLLineColTracker &     lineColTracker
452                        ,       BitBlock *                      newLineOrSkipMaskStream
453                        ,       BitBlock *                      delMaskStream
454                        ,       unsigned int &          incompleteMarkupBytes
455                        ,       unsigned int &          unusedSymbols
456                        ,       unsigned int &          unusedContent
457                        ,               unsigned int &          bytesEaten
458                ) = 0;
459
460        protected:
461
462                XMLSymbolTable *                                        fSymbolTable;
463                XMLScanner *                                            fScanner;
464                MemoryManager * const                           fMemoryManager;
465                XMLLineColTracker                                       fInternalLineColTracker;
466};
467
468//
469//  This class is a specialized transcoder that only transcodes between
470//  the internal XMLCh format and the local code page. It is specialized
471//  for the very common job of translating data from the client app's
472//  native code page to the internal format and vice versa.
473//
474class XMLUTIL_EXPORT XMLLCPTranscoder : public XMemory
475{
476public :
477        // -----------------------------------------------------------------------
478        //  Public constructors and destructor
479        // -----------------------------------------------------------------------
480        virtual ~XMLLCPTranscoder();
481
482
483        // -----------------------------------------------------------------------
484        //  The virtual transcoder API
485        //
486        //  NOTE:   All these APIs don't include null terminator characters in
487        //          their parameters. So calcRequiredSize() returns the number
488        //          of actual chars, not including the null. maxBytes and maxChars
489        //          parameters refer to actual chars, not including the null so
490        //          its assumed that the buffer is physically one char or byte
491        //          larger.
492        // -----------------------------------------------------------------------
493
494        // -----------------------------------------------------------------------
495        //  The 'normal' way to transcode a XMLCh-string from/to local string
496        //  representation
497        //
498        //  NOTE: Both methods return a string allocated via the MemoryManager.
499        //        It is the responsibility of the calling environment to
500        //        release this string after use.
501        // -----------------------------------------------------------------------
502        virtual char* transcode(const XMLCh* const toTranscode,
503                                                        MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
504
505        virtual XMLCh* transcode(const char* const toTranscode,
506                                                         MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
507
508
509        // -----------------------------------------------------------------------
510        //  DEPRECATED old transcode interface
511        // -----------------------------------------------------------------------
512        virtual XMLSize_t calcRequiredSize(const char* const srcText
513                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
514
515        virtual XMLSize_t calcRequiredSize(const XMLCh* const srcText
516                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
517
518        virtual bool transcode
519        (
520                const   char* const     toTranscode
521                ,       XMLCh* const    toFill
522                , const XMLSize_t       maxChars
523                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
524        ) = 0;
525
526        virtual bool transcode
527        (
528                const   XMLCh* const    toTranscode
529                ,       char* const     toFill
530                , const XMLSize_t       maxBytes
531                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
532        ) = 0;
533
534
535protected :
536        // -----------------------------------------------------------------------
537        //  Hidden constructors
538        // -----------------------------------------------------------------------
539        XMLLCPTranscoder();
540
541
542private :
543        // -----------------------------------------------------------------------
544        //  Unimplemented constructors and operators
545        // -----------------------------------------------------------------------
546        XMLLCPTranscoder(const XMLLCPTranscoder&);
547        XMLLCPTranscoder& operator=(const XMLLCPTranscoder&);
548};
549
550//
551// This class can be used to transcode to a target encoding. It manages the
552// memory allocated for the transcode in an exception safe manner, automatically
553// deleting it when the class goes out of scope.
554//
555class XMLUTIL_EXPORT TranscodeToStr
556{
557public:
558        // -----------------------------------------------------------------------
559        //  Public constructors and destructor
560        // -----------------------------------------------------------------------
561
562        /** Converts from the internal XMLCh* encoding to the specified encoding
563          *
564          * @param in       the null terminated source buffer to be transcoded
565          * @param encoding the name of the encoding to transcode to
566          * @param manager  the memory manager to use
567          */
568        TranscodeToStr(const XMLCh *in, const char *encoding,
569                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
570
571        /** Converts from the internal XMLCh* encoding to the specified encoding
572          *
573          * @param in       the source buffer to be transcoded
574          * @param length   the length of the source buffer
575          * @param encoding the name of the encoding to transcode to
576          * @param manager  the memory manager to use
577          */
578        TranscodeToStr(const XMLCh *in, XMLSize_t length, const char *encoding,
579                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
580
581        /** Converts from the internal XMLCh* encoding to the specified encoding
582          *
583          * @param in       the null terminated source buffer to be transcoded
584          * @param trans    the transcoder to use
585          * @param manager  the memory manager to use
586          */
587        TranscodeToStr(const XMLCh *in, XMLTranscoder* trans,
588                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
589
590        /** Converts from the internal XMLCh* encoding to the specified encoding
591          *
592          * @param in       the source buffer to be transcoded
593          * @param length   the length of the source buffer
594          * @param trans    the transcoder to use
595          * @param manager  the memory manager to use
596          */
597        TranscodeToStr(const XMLCh *in, XMLSize_t length, XMLTranscoder* trans,
598                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
599
600        ~TranscodeToStr();
601
602        /** @name Getter methods */
603        //@{
604
605        /** Returns the transcoded, null terminated string
606          * @return the transcoded string
607          */
608        const XMLByte *str() const;
609
610        /** Returns the transcoded, null terminated string - adopting
611          * the memory allocated to it from the TranscodeToStr object
612          * @return the transcoded string
613          */
614        XMLByte *adopt();
615
616        /** Returns the length of the transcoded string in bytes. The length
617          * does not include the null terminator.
618          * @return the length of the transcoded string in bytes
619          */
620        XMLSize_t length () const;
621
622                //@}
623
624private:
625        // -----------------------------------------------------------------------
626        //  Unimplemented constructors and operators
627        // -----------------------------------------------------------------------
628        TranscodeToStr(const TranscodeToStr &);
629        TranscodeToStr &operator=(const TranscodeToStr &);
630
631        // -----------------------------------------------------------------------
632        //  Private helper methods
633        // -----------------------------------------------------------------------
634        void transcode(const XMLCh *in, XMLSize_t len, XMLTranscoder* trans);
635
636        // -----------------------------------------------------------------------
637        //  Private data members
638        //
639        //  fString
640        //      The transcoded string
641        //
642        //  fBytesWritten
643        //      The length of the transcoded string in bytes
644        // -----------------------------------------------------------------------
645        XMLByte *fString;
646        XMLSize_t fBytesWritten;
647        MemoryManager *fMemoryManager;
648};
649
650//
651// This class can be used to transcode from a source encoding. It manages the
652// memory allocated for the transcode in an exception safe manner, automatically
653// deleting it when the class goes out of scope.
654//
655class XMLUTIL_EXPORT TranscodeFromStr
656{
657public:
658        // -----------------------------------------------------------------------
659        //  Public constructors and destructor
660        // -----------------------------------------------------------------------
661
662        /** Converts from the specified encoding to the internal XMLCh* encoding
663          *
664          * @param data     the source buffer to be transcoded
665          * @param length   the length of the source buffer
666          * @param encoding the name of the encoding to transcode to
667          * @param manager  the memory manager to use
668          */
669        TranscodeFromStr(const XMLByte *data, XMLSize_t length, const char *encoding,
670                                         MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
671
672        /** Converts from the specified encoding to the internal XMLCh* encoding
673          *
674          * @param data     the source buffer to be transcoded
675          * @param length   the length of the source buffer
676          * @param trans    the transcoder to use
677          * @param manager  the memory manager to use
678          */
679        TranscodeFromStr(const XMLByte *data, XMLSize_t length, XMLTranscoder *trans,
680                                         MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
681
682        ~TranscodeFromStr();
683
684        /** @name Getter methods */
685        //@{
686
687        /** Returns the transcoded, null terminated string
688          * @return the transcoded string
689          */
690        const XMLCh *str() const;
691
692        /** Returns the transcoded, null terminated string - adopting
693          * the memory allocated to it from the TranscodeFromStr object
694          * @return the transcoded string
695          */
696        XMLCh *adopt();
697
698        /** Returns the length of the transcoded string in characters. The length
699          * does not include the null terminator.
700          * @return the length of the transcoded string in characters
701          */
702        XMLSize_t length() const;
703
704                //@}
705
706private:
707        // -----------------------------------------------------------------------
708        //  Unimplemented constructors and operators
709        // -----------------------------------------------------------------------
710        TranscodeFromStr(const TranscodeFromStr &);
711        TranscodeFromStr &operator=(const TranscodeFromStr &);
712
713        // -----------------------------------------------------------------------
714        //  Private helper methods
715        // -----------------------------------------------------------------------
716        void transcode(const XMLByte *in, XMLSize_t length, XMLTranscoder *trans);
717
718        // -----------------------------------------------------------------------
719        //  Private data members
720        //
721        //  fString
722        //      The transcoded string
723        //
724        //  fBytesWritten
725        //      The length of the transcoded string in characters
726        // -----------------------------------------------------------------------
727        XMLCh *fString;
728        XMLSize_t fCharsWritten;
729        MemoryManager *fMemoryManager;
730};
731
732// ---------------------------------------------------------------------------
733//  XMLTranscoder: Getter methods
734// ---------------------------------------------------------------------------
735inline MemoryManager* XMLTranscoder::getMemoryManager() const
736{
737        return fMemoryManager;
738}
739
740// ---------------------------------------------------------------------------
741//  XMLTranscoder: Protected helper methods
742// ---------------------------------------------------------------------------
743inline XMLSize_t XMLTranscoder::getBlockSize() const
744{
745        return fBlockSize;
746}
747
748inline const XMLCh* XMLTranscoder::getEncodingName() const
749{
750        return fEncodingName;
751}
752
753// ---------------------------------------------------------------------------
754//  TranscodeToStr: Getter methods
755// ---------------------------------------------------------------------------
756inline const XMLByte *TranscodeToStr::str() const
757{
758        return fString;
759}
760
761inline XMLByte *TranscodeToStr::adopt()
762{
763        XMLByte *tmp = fString;
764        fString = 0;
765        return tmp;
766}
767
768inline XMLSize_t TranscodeToStr::length () const
769{
770        return fBytesWritten;
771}
772
773// ---------------------------------------------------------------------------
774//  TranscodeFromStr: Getter methods
775// ---------------------------------------------------------------------------
776inline const XMLCh *TranscodeFromStr::str() const
777{
778        return fString;
779}
780
781inline XMLCh *TranscodeFromStr::adopt()
782{
783        XMLCh *tmp = fString;
784        fString = 0;
785        return tmp;
786}
787
788inline XMLSize_t TranscodeFromStr::length() const
789{
790        return fCharsWritten;
791}
792
793XERCES_CPP_NAMESPACE_END
794
795#endif
Note: See TracBrowser for help on using the repository browser.