libxalan-c-dev 1.11-3 / usr / include / xalanc / XMLSupport / XalanUTF8Writer.hpp

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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(XALANUTF8WRITER_HEADER_GUARD_1357924680)
#define XALANUTF8WRITER_HEADER_GUARD_1357924680


#include <xalanc/XMLSupport/XalanFormatterWriter.hpp>



XALAN_CPP_NAMESPACE_BEGIN



inline char
bits19to21(XalanUnicodeChar     theChar)
{
    return static_cast<char>((theChar >> 18) & 0x7);
}



inline char
bits13to18(XalanUnicodeChar     theChar)
{
    return static_cast<char>((theChar >> 12) & 0x3F);
}



inline char
bits13to16(XalanUnicodeChar     theChar)
{
    return static_cast<char>((theChar >> 12) & 0xF);
}



inline char
bits7to12(XalanUnicodeChar      theChar)
{
    return static_cast<char>((theChar >> 6) & 0x3f);
}



inline char
bits7to11(XalanUnicodeChar      theChar)
{
    return static_cast<char>((theChar >> 6) & 0x1f);
}



inline char
bits1to6(XalanUnicodeChar       theChar)
{
    return static_cast<char>(theChar & 0x3f);
}



inline char
leadingByteOf2(char     theBits)
{
    return static_cast<char>(0xC0 + theBits);
}



inline char
leadingByteOf3(char     theBits)
{
    return static_cast<char>(0xE0 + theBits);
}



inline char
leadingByteOf4(char     theBits)
{
    return static_cast<char>(0xF0 + theBits);
}



inline char
trailingByte(char   theBits)
{
    return static_cast<char>(0x80 + theBits);
}



class XalanUTF8Writer : public XalanFormatterWriter
{
public:

    typedef char    value_type;
 

    XalanUTF8Writer(
                Writer&         writer,
                MemoryManager&  theMemoryManager);

    virtual
    ~XalanUTF8Writer()
    {
    }

    /**
     * Output a line break.
     */
    void
    outputNewline()
    {
        assert(m_newlineString != 0);
        assert(length(m_newlineString) == m_newlineStringLength);

        write(
            m_newlineString,
            m_newlineStringLength);
    }

    size_type
    writeCDATAChar(
                const XalanDOMChar  chars[],
                size_type           start,
                size_type           length,
                bool&               /* outsideCDATA */)
    {
        assert(chars != 0 && length != 0 && start < length);

        return write(chars, start, length);
    }

    /**
     * Writes name characters.  If characters that are not
     * representable are encountered, an exception is thrown.
     */
    void
    writeNameChar(
            const XalanDOMChar*      data,
            size_type                theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes PI characters.  If characters that are not
     * representable are encountered, an exception is thrown.
     */
    void
    writePIChars(
            const XalanDOMChar*     data,
            size_type               theLength)
    {
        write(data, theLength);
    }

    /**
     * Writes comment characters.  If characters that are not
     * representable are encountered, an exception is thrown.
     */
    void
    writeCommentChars(
            const XalanDOMChar*      data,
            size_type                theLength)
    {
        write(data, theLength);
    }

    void
    safeWriteContent(
            const XalanDOMChar*     theChars,
            size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        { 
            write(value_type(theChars[i]));
        }
    }

    void
    write(
            const value_type*   theChars,
            size_type           theLength)
    {
    #if defined(NDEBUG)
        if (theLength > sizeof(m_buffer))
        {
            flushBuffer();
    
            m_writer.write(theChars, 0, theLength);
        }
        else
        {
            if (m_bufferRemaining < theLength)
            {
                flushBuffer();
            }
    
            for(size_type i = 0; i < theLength; ++i)
            {
                *m_bufferPosition = theChars[i];
    
                ++m_bufferPosition;
            }
    
            m_bufferRemaining -= theLength;
        }
    #else
        for(size_type i = 0; i < theLength; ++i)
        {
            write(theChars[i]);
        }
    #endif
    }

    void
    write(const XalanDOMChar*   theChars)
    {
        write(theChars, XalanDOMString::length(theChars));
    }

    void
    write(const XalanDOMString&     theChars)
    {
        write(theChars.c_str(), theChars.length());
    }

    void
    write(value_type    theChar)
    {
        assert(theChar < 128);
    
        if (m_bufferRemaining == 0)
        {
            flushBuffer();
        }

        *m_bufferPosition = theChar;

        ++m_bufferPosition;
        --m_bufferRemaining;
    }

    void
    write(
            const XalanDOMChar*     theChars,
            size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        {
            if (isUTF16HighSurrogate(theChars[i]) == false)
            {
                write(static_cast<XalanUnicodeChar>(theChars[i]));
            }
            else if (i + 1 >= theLength)
            {
                throwInvalidUTF16SurrogateException(
                    theChars[i], 
                    0,
                    getMemoryManager());
            }
            else 
            {
                write(
                    decodeUTF16SurrogatePair(
                        theChars[i],
                        theChars[i + 1],
                        getMemoryManager()));

                ++i;
            }
        }
    }

    size_type
    write(
            const XalanDOMChar  chars[],
            size_type           start,
            size_type           length)
    {
        const XalanDOMChar  ch = chars[start];

        if (isUTF16HighSurrogate(ch) == false)
        {
            write(static_cast<XalanUnicodeChar>(ch));
        }
        else if (start + 1 >= length)
        {
            throwInvalidUTF16SurrogateException(
                ch, 
                0,
                getMemoryManager());
        }
        else
        {
            write(
                decodeUTF16SurrogatePair(
                    ch,
                    chars[++start],
                    getMemoryManager()));
        }

        return start;
    }

    void
    writeSafe(
        const XalanDOMChar*     theChars,
        size_type               theLength)
    {
        for(size_type i = 0; i < theLength; ++i)
        {
            const XalanDOMChar  ch = theChars[i];

            if (isUTF16HighSurrogate(ch) == true)
            {
                if (i + 1 >= theLength)
                {
                    throwInvalidUTF16SurrogateException(
                        ch,
                        0,
                        getMemoryManager());
                }
                else 
                {
                    write(
                        decodeUTF16SurrogatePair(
                            ch,
                            theChars[i + 1],
                            getMemoryManager()));

                    ++i;
                }
            }
            else
            {
                write(static_cast<XalanUnicodeChar>(ch));
            }
        }
        
    }

    void
    write(const value_type*     theChars)
    {
        write(theChars, XalanDOMString::length(theChars));
    }

    void
    flushWriter()
    {
        m_writer.flush();
    }    

    void
    flushBuffer()
    {
        m_writer.write(m_buffer, 0, m_bufferPosition - m_buffer);
    
        m_bufferPosition = m_buffer;
        m_bufferRemaining = kBufferSize;
    }

private:

    void
    write(XalanUnicodeChar  theChar)
    {
        if (theChar <= 0x7F)
        {
            write(char(theChar));
        }
        else if (theChar <= 0x7FF)
        {
            if (m_bufferRemaining < 2)
            {
                flushBuffer();
            }

            *m_bufferPosition = leadingByteOf2(bits7to11(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits1to6(theChar));
            ++m_bufferPosition;

            m_bufferRemaining -= 2;
        }
        else if (theChar <= 0xFFFF)
        {
            // We should never get a high or low surrogate here...
            assert(theChar < 0xD800 || theChar > 0xDBFF);
            assert(theChar < 0xDC00 || theChar > 0xDFFF);

            if (m_bufferRemaining < 3)
            {
                flushBuffer();
            }

            *m_bufferPosition = leadingByteOf3(bits13to16(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits7to12(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits1to6(theChar));
            ++m_bufferPosition;

            m_bufferRemaining -= 3;
        }
        else if (theChar <= 0x10FFFF)
        {
            if (m_bufferRemaining < 4)
            {
                flushBuffer();
            }

            *m_bufferPosition = leadingByteOf4(bits19to21(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits13to18(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits7to12(theChar));
            ++m_bufferPosition;
            *m_bufferPosition = trailingByte(bits1to6(theChar));
            ++m_bufferPosition;

            m_bufferRemaining -= 4;
        }
        else
        {
            throwInvalidCharacterException(theChar, getMemoryManager());
        }
    }

    enum
    {
        kBufferSize = 512       // The size of the buffer
    };


    // Data members...
    value_type      m_buffer[kBufferSize];

    value_type*     m_bufferPosition;

    size_type       m_bufferRemaining;
};



XALAN_CPP_NAMESPACE_END



#endif  // XALANUTF8WRITER_HEADER_GUARD_1357924680