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

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

Changes to icxercesc files

File size: 26.1 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 <icxmlc/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/XMLParserDefs.hpp>
33
34XERCES_CPP_NAMESPACE_BEGIN
35
36// Forward references
37class XMLLCPTranscoder;
38class XMLTranscoder;
39class ENameMap;
40class XMLScanner;
41class XMLSymbolTable;
42class XMLReferenceTable;
43class XMLParser;
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
193private :
194        // -----------------------------------------------------------------------
195        //  Unimplemented constructors and operators
196        // -----------------------------------------------------------------------
197        XMLTransService(const XMLTransService&);
198        XMLTransService& operator=(const XMLTransService&);
199
200        // -----------------------------------------------------------------------
201        //  Hidden method to enable/disable strict IANA encoding check
202        //  Caller: XMLPlatformUtils
203        // -----------------------------------------------------------------------
204        void strictIANAEncoding(const bool newState);
205        bool isStrictIANAEncoding();
206
207        friend class XMLInitializer;
208};
209
210/**
211  *   <code>XMLTranscoder</code> is for transcoding non-local code
212  *   page encodings, i.e.  named encodings. These are used internally
213  *   by the scanner to internalize raw XML into the internal Unicode
214  *   format, and by writer classes to convert that internal Unicode
215  *   format (which comes out of the parser) back out to a format that
216  *   the receiving client code wants to use.
217  */
218class XMLUTIL_EXPORT XMLTranscoder : public XMemory
219{
220public :
221
222                /**
223                 * This enum is used by the <code>transcodeTo()</code> method
224                 * to indicate how to react to unrepresentable characters. The
225                 * <code>transcodeFrom()</code> method always works the
226                 * same. It will consider any invalid data to be an error and
227                 * throw.
228                 */
229        enum UnRepOpts
230        {
231                UnRep_Throw             /**< Throw an exception */
232                , UnRep_RepChar         /**< Use the replacement char */
233        };
234
235
236                /** @name Destructor. */
237                //@{
238
239                 /**
240                  * Destructor for XMLTranscoder
241                  *
242                  */
243        virtual ~XMLTranscoder();
244                //@}
245
246
247
248        /** @name The virtual transcoding interface */
249        //@{
250
251        /** Converts from the encoding of the service to the internal XMLCh* encoding
252          *
253          * @param srcData the source buffer to be transcoded
254          * @param srcCount number of bytes in the source buffer
255          * @param toFill the destination buffer
256          * @param maxChars the max number of characters in the destination buffer
257          * @param bytesEaten after transcoding, this will hold the number of bytes
258          *    that were processed from the source buffer
259          * @param charSizes an array which must be at least as big as maxChars
260          *    into which will be inserted values that indicate how many
261          *    bytes from the input went into each XMLCh that was created
262          *    into toFill. Since many encodings use variable numbers of
263          *    byte per character, this provides a means to find out what
264          *    bytes in the input went into making a particular output
265          *    UTF-16 character.
266          * @return Returns the number of chars put into the target buffer
267          */
268        virtual XMLSize_t transcodeFrom
269        (
270                const   XMLByte* const          srcData
271                , const XMLSize_t               srcCount
272                ,       XMLCh* const            toFill
273                , const XMLSize_t               maxChars
274                ,       XMLSize_t&              bytesEaten
275                ,       unsigned char* const    charSizes
276        ) = 0;
277
278    virtual XMLSize_t transcodeFrom
279    (
280        const   XMLByte* const          srcData
281        , const XMLSize_t               srcCount
282        ,       XMLCh* const            toFill
283        , const XMLSize_t               maxChars
284        ,       XMLSize_t&              bytesEaten
285    ) = 0;
286
287    /** Converts from the encoding of the service to the internal XMLCh* encoding
288      *
289      * @param srcData the source buffer to be transcoded
290      * @param srcCount number of bytes in the source buffer
291      * @param toFill the destination XMLBuffer
292      * @return Returns the number of chars put into the target buffer
293      */
294        virtual XMLSize_t transcodeFrom
295        (
296                  const XMLByte* const          srcData
297                , const XMLSize_t               srcCount
298                ,       XMLBuffer &             toFill
299    ) = 0;
300
301        /** Converts from the internal XMLCh* encoding to the encoding of the service
302          *
303          * @param srcData    the source buffer to be transcoded
304          * @param srcCount   number of characters in the source buffer
305          * @param toFill     the destination buffer
306          * @param maxBytes   the max number of bytes in the destination buffer
307          * @param charsEaten after transcoding, this will hold the number of chars
308          *    that were processed from the source buffer
309          * @param options    options to pass to the transcoder that explain how to
310          *    respond to an unrepresentable character
311          * @return Returns the number of chars put into the target buffer
312          */
313
314        virtual XMLSize_t transcodeTo
315        (
316                const   XMLCh* const    srcData
317                , const XMLSize_t       srcCount
318                ,       XMLByte* const  toFill
319                , const XMLSize_t       maxBytes
320                ,       XMLSize_t&      charsEaten
321                , const UnRepOpts       options
322        ) = 0;
323
324        /** Query whether the transcoder can handle a given character
325          *
326          * @param toCheck   the character code point to check
327          */
328
329        virtual bool canTranscodeTo
330        (
331                const   unsigned int    toCheck
332        ) = 0;
333
334        //@}
335
336        /** @name Getter methods */
337        //@{
338
339        /** Get the internal block size
340         *
341           * @return The block size indicated in the constructor.
342           */
343        XMLSize_t getBlockSize() const;
344
345        /** Get the encoding name
346          *
347          * @return the name of the encoding that this
348          *    <code>XMLTranscoder</code> object is for
349          */
350        const XMLCh* getEncodingName() const;
351                //@}
352
353        /** @name Getter methods*/
354        //@{
355
356        /** Get the plugged-in memory manager
357          *
358          * This method returns the plugged-in memory manager user for dynamic
359          * memory allocation/deallocation.
360          *
361          * @return the plugged-in memory manager
362          */
363        MemoryManager* getMemoryManager() const;
364
365
366    /** Get the plugged-in memory manager
367      *
368      * Returns whether the endianness of the character set encoding is swapped
369      * with respect to the endianness of the current architecture.
370      *
371      * @return true/false
372      */
373    virtual bool isSwapped() const;
374
375                //@}
376
377protected :
378        // -----------------------------------------------------------------------
379        //  Hidden constructors
380        // -----------------------------------------------------------------------
381        XMLTranscoder
382        (
383                const   XMLCh* const    encodingName
384                , const XMLSize_t       blockSize
385                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
386        );
387
388
389        // -----------------------------------------------------------------------
390        //  Protected helper methods
391        // -----------------------------------------------------------------------
392
393private :
394        // -----------------------------------------------------------------------
395        //  Unimplemented constructors and operators
396        // -----------------------------------------------------------------------
397        XMLTranscoder(const XMLTranscoder&);
398        XMLTranscoder& operator=(const XMLTranscoder&);
399
400        // -----------------------------------------------------------------------
401        //  Private data members
402        //
403        //  fBlockSize
404        //      This is the block size indicated in the constructor.
405        //
406        //  fEncodingName
407        //      This is the name of the encoding this encoder is for. All basic
408        //      XML transcoder's are for named encodings.
409        // -----------------------------------------------------------------------
410        XMLSize_t       fBlockSize;
411        XMLCh*          fEncodingName;
412        MemoryManager*  fMemoryManager;
413};
414
415class XMLCharacterSetAdapter
416{
417        public:
418                // -----------------------------------------------------------------------
419                //  Public constructors and destructor
420                // -----------------------------------------------------------------------
421                XMLCharacterSetAdapter(MemoryManager * manager)
422        : fScanner(0)
423        , fSymbolTable(0)
424        , fReferenceTable(0)
425                , fMemoryManager(manager)
426                {
427
428                }
429
430                virtual ~XMLCharacterSetAdapter() = 0;
431
432                inline void init
433                (
434            XMLScanner * const                  scanner
435            , XMLSymbolTable &              symbolTable
436            , XMLReferenceTable &           referenceTable
437            , const XMLFileLoc              line
438            , const XMLFileLoc              column
439                )
440                {
441            fScanner = scanner;
442            fSymbolTable = &symbolTable;
443            fReferenceTable = &referenceTable;
444            fLine = line;
445            fColumn = column;
446                }
447
448                virtual XMLSize_t getCodeUnitSize() = 0;
449
450        virtual void parse
451                (
452            const XMLByte * const               input
453            , const size_t              avail
454            , const bool                                noMore
455            , XMLParser &               parser
456            ,           size_t &            bytesEaten
457                ) = 0;
458
459        inline XMLSymbolTable & getSymbolTable() const
460        {
461            return *fSymbolTable;
462        }
463
464        inline XMLReferenceTable & getReferenceTable() const
465        {
466            return *fReferenceTable;
467        }
468
469        protected:
470
471        XMLScanner *                                            fScanner;
472                XMLSymbolTable *                                        fSymbolTable;
473        XMLReferenceTable *                 fReferenceTable;                           
474        MemoryManager * const                           fMemoryManager;
475        XMLFileLoc                          fLine;
476        XMLFileLoc                          fColumn;
477};
478
479//
480//  This class is a specialized transcoder that only transcodes between
481//  the internal XMLCh format and the local code page. It is specialized
482//  for the very common job of translating data from the client app's
483//  native code page to the internal format and vice versa.
484//
485class XMLUTIL_EXPORT XMLLCPTranscoder : public XMemory
486{
487public :
488        // -----------------------------------------------------------------------
489        //  Public constructors and destructor
490        // -----------------------------------------------------------------------
491        virtual ~XMLLCPTranscoder();
492
493
494        // -----------------------------------------------------------------------
495        //  The virtual transcoder API
496        //
497        //  NOTE:   All these APIs don't include null terminator characters in
498        //          their parameters. So calcRequiredSize() returns the number
499        //          of actual chars, not including the null. maxBytes and maxChars
500        //          parameters refer to actual chars, not including the null so
501        //          its assumed that the buffer is physically one char or byte
502        //          larger.
503        // -----------------------------------------------------------------------
504
505        // -----------------------------------------------------------------------
506        //  The 'normal' way to transcode a XMLCh-string from/to local string
507        //  representation
508        //
509        //  NOTE: Both methods return a string allocated via the MemoryManager.
510        //        It is the responsibility of the calling environment to
511        //        release this string after use.
512        // -----------------------------------------------------------------------
513        virtual char* transcode(const XMLCh* const toTranscode,
514                                                        MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
515
516        virtual XMLCh* transcode(const char* const toTranscode,
517                                                         MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
518
519
520        // -----------------------------------------------------------------------
521        //  DEPRECATED old transcode interface
522        // -----------------------------------------------------------------------
523        virtual XMLSize_t calcRequiredSize(const char* const srcText
524                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
525
526        virtual XMLSize_t calcRequiredSize(const XMLCh* const srcText
527                , MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager) = 0;
528
529        virtual bool transcode
530        (
531                const   char* const     toTranscode
532                ,       XMLCh* const    toFill
533                , const XMLSize_t       maxChars
534                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
535        ) = 0;
536
537        virtual bool transcode
538        (
539                const   XMLCh* const    toTranscode
540                ,       char* const     toFill
541                , const XMLSize_t       maxBytes
542                , MemoryManager* const  manager = XMLPlatformUtils::fgMemoryManager
543        ) = 0;
544
545
546protected :
547        // -----------------------------------------------------------------------
548        //  Hidden constructors
549        // -----------------------------------------------------------------------
550        XMLLCPTranscoder();
551
552
553private :
554        // -----------------------------------------------------------------------
555        //  Unimplemented constructors and operators
556        // -----------------------------------------------------------------------
557        XMLLCPTranscoder(const XMLLCPTranscoder&);
558        XMLLCPTranscoder& operator=(const XMLLCPTranscoder&);
559};
560
561//
562// This class can be used to transcode to a target encoding. It manages the
563// memory allocated for the transcode in an exception safe manner, automatically
564// deleting it when the class goes out of scope.
565//
566class XMLUTIL_EXPORT TranscodeToStr
567{
568public:
569        // -----------------------------------------------------------------------
570        //  Public constructors and destructor
571        // -----------------------------------------------------------------------
572
573        /** Converts from the internal XMLCh* encoding to the specified encoding
574          *
575          * @param in       the null terminated source buffer to be transcoded
576          * @param encoding the name of the encoding to transcode to
577          * @param manager  the memory manager to use
578          */
579        TranscodeToStr(const XMLCh *in, const char *encoding,
580                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
581
582        /** Converts from the internal XMLCh* encoding to the specified encoding
583          *
584          * @param in       the source buffer to be transcoded
585          * @param length   the length of the source buffer
586          * @param encoding the name of the encoding to transcode to
587          * @param manager  the memory manager to use
588          */
589        TranscodeToStr(const XMLCh *in, XMLSize_t length, const char *encoding,
590                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
591
592        /** Converts from the internal XMLCh* encoding to the specified encoding
593          *
594          * @param in       the null terminated source buffer to be transcoded
595          * @param trans    the transcoder to use
596          * @param manager  the memory manager to use
597          */
598        TranscodeToStr(const XMLCh *in, XMLTranscoder* trans,
599                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
600
601        /** Converts from the internal XMLCh* encoding to the specified encoding
602          *
603          * @param in       the source buffer to be transcoded
604          * @param length   the length of the source buffer
605          * @param trans    the transcoder to use
606          * @param manager  the memory manager to use
607          */
608        TranscodeToStr(const XMLCh *in, XMLSize_t length, XMLTranscoder* trans,
609                                   MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
610
611        ~TranscodeToStr();
612
613        /** @name Getter methods */
614        //@{
615
616        /** Returns the transcoded, null terminated string
617          * @return the transcoded string
618          */
619        const XMLByte *str() const;
620
621        /** Returns the transcoded, null terminated string - adopting
622          * the memory allocated to it from the TranscodeToStr object
623          * @return the transcoded string
624          */
625        XMLByte *adopt();
626
627        /** Returns the length of the transcoded string in bytes. The length
628          * does not include the null terminator.
629          * @return the length of the transcoded string in bytes
630          */
631        XMLSize_t length () const;
632
633                //@}
634
635private:
636        // -----------------------------------------------------------------------
637        //  Unimplemented constructors and operators
638        // -----------------------------------------------------------------------
639        TranscodeToStr(const TranscodeToStr &);
640        TranscodeToStr &operator=(const TranscodeToStr &);
641
642        // -----------------------------------------------------------------------
643        //  Private helper methods
644        // -----------------------------------------------------------------------
645        void transcode(const XMLCh *in, XMLSize_t len, XMLTranscoder* trans);
646
647        // -----------------------------------------------------------------------
648        //  Private data members
649        //
650        //  fString
651        //      The transcoded string
652        //
653        //  fBytesWritten
654        //      The length of the transcoded string in bytes
655        // -----------------------------------------------------------------------
656        XMLByte *fString;
657        XMLSize_t fBytesWritten;
658        MemoryManager *fMemoryManager;
659};
660
661//
662// This class can be used to transcode from a source encoding. It manages the
663// memory allocated for the transcode in an exception safe manner, automatically
664// deleting it when the class goes out of scope.
665//
666class XMLUTIL_EXPORT TranscodeFromStr
667{
668public:
669        // -----------------------------------------------------------------------
670        //  Public constructors and destructor
671        // -----------------------------------------------------------------------
672
673        /** Converts from the specified encoding to the internal XMLCh* encoding
674          *
675          * @param data     the source buffer to be transcoded
676          * @param length   the length of the source buffer
677          * @param encoding the name of the encoding to transcode to
678          * @param manager  the memory manager to use
679          */
680        TranscodeFromStr(const XMLByte *data, XMLSize_t length, const char *encoding,
681                                         MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
682
683        /** Converts from the specified encoding to the internal XMLCh* encoding
684          *
685          * @param data     the source buffer to be transcoded
686          * @param length   the length of the source buffer
687          * @param trans    the transcoder to use
688          * @param manager  the memory manager to use
689          */
690        TranscodeFromStr(const XMLByte *data, XMLSize_t length, XMLTranscoder *trans,
691                                         MemoryManager *manager = XMLPlatformUtils::fgMemoryManager);
692
693        ~TranscodeFromStr();
694
695        /** @name Getter methods */
696        //@{
697
698        /** Returns the transcoded, null terminated string
699          * @return the transcoded string
700          */
701        const XMLCh *str() const;
702
703        /** Returns the transcoded, null terminated string - adopting
704          * the memory allocated to it from the TranscodeFromStr object
705          * @return the transcoded string
706          */
707        XMLCh *adopt();
708
709        /** Returns the length of the transcoded string in characters. The length
710          * does not include the null terminator.
711          * @return the length of the transcoded string in characters
712          */
713        XMLSize_t length() const;
714
715                //@}
716
717private:
718        // -----------------------------------------------------------------------
719        //  Unimplemented constructors and operators
720        // -----------------------------------------------------------------------
721        TranscodeFromStr(const TranscodeFromStr &);
722        TranscodeFromStr &operator=(const TranscodeFromStr &);
723
724        // -----------------------------------------------------------------------
725        //  Private helper methods
726        // -----------------------------------------------------------------------
727        void transcode(const XMLByte *in, XMLSize_t length, XMLTranscoder *trans);
728
729        // -----------------------------------------------------------------------
730        //  Private data members
731        //
732        //  fString
733        //      The transcoded string
734        //
735        //  fBytesWritten
736        //      The length of the transcoded string in characters
737        // -----------------------------------------------------------------------
738        XMLCh *fString;
739        XMLSize_t fCharsWritten;
740        MemoryManager *fMemoryManager;
741};
742
743// ---------------------------------------------------------------------------
744//  XMLTranscoder: Getter methods
745// ---------------------------------------------------------------------------
746inline MemoryManager* XMLTranscoder::getMemoryManager() const
747{
748        return fMemoryManager;
749}
750
751// ---------------------------------------------------------------------------
752//  XMLTranscoder: Protected helper methods
753// ---------------------------------------------------------------------------
754inline XMLSize_t XMLTranscoder::getBlockSize() const
755{
756        return fBlockSize;
757}
758
759inline const XMLCh* XMLTranscoder::getEncodingName() const
760{
761        return fEncodingName;
762}
763
764// ---------------------------------------------------------------------------
765//  TranscodeToStr: Getter methods
766// ---------------------------------------------------------------------------
767inline const XMLByte *TranscodeToStr::str() const
768{
769        return fString;
770}
771
772inline XMLByte *TranscodeToStr::adopt()
773{
774        XMLByte *tmp = fString;
775        fString = 0;
776        return tmp;
777}
778
779inline XMLSize_t TranscodeToStr::length () const
780{
781        return fBytesWritten;
782}
783
784// ---------------------------------------------------------------------------
785//  TranscodeFromStr: Getter methods
786// ---------------------------------------------------------------------------
787inline const XMLCh *TranscodeFromStr::str() const
788{
789        return fString;
790}
791
792inline XMLCh *TranscodeFromStr::adopt()
793{
794        XMLCh *tmp = fString;
795        fString = 0;
796        return tmp;
797}
798
799inline XMLSize_t TranscodeFromStr::length() const
800{
801        return fCharsWritten;
802}
803
804XERCES_CPP_NAMESPACE_END
805
806#endif
Note: See TracBrowser for help on using the repository browser.