Xalan-C++ API Documentation

The Xalan C++ XSLT Processor Version 1.10

             

---

XalanTranscodingServices.hpp

Go to the documentation of this file.

/*
 * Copyright 1999-2004 The Apache Software Foundation.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if !defined(XALANTRANSCODINGSERVICES_HEADER_GUARD_1357924680)
#define XALANTRANSCODINGSERVICES_HEADER_GUARD_1357924680



// Base include file.  Must be first.
#include <xalanc/PlatformSupport/PlatformSupportDefinitions.hpp>



#include <cassert>



#include <xalanc/PlatformSupport/DOMStringHelper.hpp>
#include <xalanc/PlatformSupport/XSLException.hpp>



XALAN_CPP_NAMESPACE_BEGIN



class XalanOutputTranscoder;



class XALAN_PLATFORMSUPPORT_EXPORT XalanTranscodingServices
{
public:

    static void
    initialize(MemoryManagerType&      theManager);
 
    static void
    terminate();

    typedef unsigned char   XalanXMLByte;
    typedef unsigned int    size_type;
    typedef unsigned int    UnicodeCharType;

    static size_type
    length(const XalanXMLByte*  theBytes)
    {
        assert(theBytes != 0);

        size_type   i = 0;

        while(theBytes[i] != 0)
        {
            ++i;
        }

        return i;
    }

    enum eCode
    {
        OK,
        UnsupportedEncoding,
        InternalFailure,
        SupportFilesNotFound
    };


    static XalanOutputTranscoder*
    makeNewTranscoder(
            MemoryManagerType&      theManager,
            const XalanDOMString&   theEncodingName,
            eCode&                  theResult,
            size_type               theBlockSize);

    static void
    destroyTranscoder(XalanOutputTranscoder*    theTranscoder);

    static bool
    encodingIsUTF8(const XalanDOMChar*      theEncodingName);

    static bool
    encodingIsUTF8(const XalanDOMString&    theEncodingName);

    static bool
    encodingIsUTF16(const XalanDOMChar*     theEncodingName);

    static bool
    encodingIsUTF16(const XalanDOMString&   theEncodingName);

    static bool
    encodingIsUTF32(const XalanDOMChar*     theEncodingName);

    static bool
    encodingIsUTF32(const XalanDOMString&   theEncodingName);
    static const XalanXMLByte*
    getStreamProlog(const XalanDOMString&   theEncodingName);

    static XalanDOMChar
    getMaximumCharacterValue(const XalanDOMString&  theEncoding);

    static XalanDOMChar
    getMaximumCharacterValue();

    static bool
    getBytesEqualChars(const XalanDOMString&    theEncoding);

    static bool
    canTranscodeToLocalCodePage(UnicodeCharType     theChar)
    {
        // Yuck!! See getMaximumCharacterValue() for more details.
        return theChar <= 0x7fu ? true : false;
    }

    static const XalanDOMChar   s_utf8String[];

    static const XalanDOMChar   s_utf16String[];

    static const XalanDOMChar   s_utf16LEString[];

    static const XalanDOMChar   s_utf16BEString[];

    static const XalanDOMChar   s_utf32String[];

    static const XalanDOMChar   s_asciiString[];

    static const XalanDOMChar   s_usASCIIString[];

    static const XalanDOMChar   s_windows1250String[];

    static const XalanDOMChar   s_iso88591String[];

    static const XalanDOMChar   s_shiftJISString[];


    class XALAN_PLATFORMSUPPORT_EXPORT UnrepresentableCharacterException : public XSLException
    {
    public:

        UnrepresentableCharacterException(
            UnicodeCharType         theCharacter,
            const XalanDOMString&   theEncoding,
            XalanDOMString&         theBuffer);

        virtual
        ~UnrepresentableCharacterException();

        UnicodeCharType
        getCharacter() const
        {
            return m_badCharacter;
        }

        const XalanDOMString&
        getEncoding() const
        {
            return m_encoding;
        }

        virtual const XalanDOMChar*
        getType() const
        {
            return m_type;
        }

    private:
        // not implemented
        UnrepresentableCharacterException(const UnrepresentableCharacterException&);

        static const XalanDOMChar   m_type[];


        const UnicodeCharType   m_badCharacter;

        const XalanDOMString    m_encoding;
    };

private:

    static const XalanXMLByte   s_dummyByteOrderMark[];
    static const XalanXMLByte   s_UTF8ByteOrderMark[];
    static const XalanDOMChar   s_UTF16ByteOrderMark[];
};



class XALAN_PLATFORMSUPPORT_EXPORT XalanOutputTranscoder
{
public:

    typedef XalanTranscodingServices::XalanXMLByte      XalanXMLByte;
    typedef XalanTranscodingServices::eCode             eCode;
    typedef XalanTranscodingServices::size_type         size_type;
    typedef XalanTranscodingServices::UnicodeCharType   UnicodeCharType;

    explicit
    XalanOutputTranscoder(MemoryManagerType& theManager);

    virtual
    ~XalanOutputTranscoder();

    MemoryManagerType&
    getMemoryManager()
    {
        return m_memoryManager;
    }

    virtual eCode
    transcode(
            const XalanDOMChar*     theSourceData,
            size_type               theSourceCount,
            XalanXMLByte*           theTarget,
            size_type               theTargetSize,
            size_type&              theSourceCharsTranscoded,
            size_type&              theTargetBytesUsed) = 0;

    virtual eCode
    transcode(
            const XalanXMLByte*     theSourceData,
            size_type               theSourceCount,
            XalanDOMChar*           theTarget,
            size_type               theTargetSize,
            size_type&              theSourceCharsTranscoded,
            size_type&              theTargetBytesUsed,
            unsigned char*          theCharSizes) = 0;

    virtual bool
    canTranscodeTo(UnicodeCharType  theChar) const = 0;

private:

    MemoryManagerType&              m_memoryManager;
    // Not implemented...
    XalanOutputTranscoder(const XalanOutputTranscoder&  theSource);

    bool
    operator==(const XalanOutputTranscoder& theRHS) const;

    XalanOutputTranscoder&
    operator=(const XalanOutputTranscoder&  theRHS);
};



XALAN_CPP_NAMESPACE_END



#endif  // XALANTRANSCODINGSERVICES_HEADER_GUARD_1357924680

Interpreting class diagrams

Doxygen and GraphViz are used to generate this API documentation from the Xalan-C header files.

Xalan-C++ XSLT Processor Version 1.10 Copyright © 1999-2004 The Apache Software Foundation. All Rights Reserved.