/*
 * 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(FORMATTERTOTEXT_HEADER_GUARD_1357924680)
#define FORMATTERTOTEXT_HEADER_GUARD_1357924680


// Base include file.  Must be first.
#include <xalanc/XMLSupport/XMLSupportDefinitions.hpp>


#include <xalanc/XalanDOM/XalanDOMString.hpp>


// Base class header file.
#include <xalanc/PlatformSupport/FormatterListener.hpp>


namespace XALAN_CPP_NAMESPACE {


class Writer;


/**
 * This class takes SAX events (in addition to some extra events 
 * that SAX doesn't handle yet) and produces simple text only.
 */
class XALAN_XMLSUPPORT_EXPORT FormatterToText : public FormatterListener
{
public:

    /**
     * FormatterToText instance constructor.
     */
    FormatterToText(MemoryManager& theManager XALAN_DEFAULT_CONSTRUCTOR_MEMMGR);

    /**
     * FormatterToText instance constructor.
     *
     * @param writer writer for output
     * @param normalizeLindefeed Normalize \n or \r\n (on certain platforms).
     * @param handleIgnorableWhitespace If true ignorableWhitespace() will write data to the Writer
     */
    FormatterToText(
            Writer&             writer,
            bool                normalizeLinefeed = true,
            bool                handleIgnorableWhitespace = true,
            MemoryManager&  theManager XALAN_DEFAULT_MEMMGR);

    /**
     * FormatterToText instance constructor.
     *
     * @param writer writer for output
     * @param encoding character encoding for the writer
     * @param normalizeLindefeed Normalize \n or \r\n on certain platforms.
     * @param handleIgnorableWhitespace If true ignorableWhitespace() will write data to the Writer
     */
    FormatterToText(
            Writer&                 writer,
            const XalanDOMString&   encoding,
            bool                    normalizeLinefeed = true,
            bool                    handleIgnorableWhitespace = true,
            MemoryManager&      theManager XALAN_DEFAULT_MEMMGR);

    static FormatterToText*
    create(
            MemoryManager&      theManager,
            Writer&                 writer,
            const XalanDOMString&   encoding,
            bool                    normalizeLinefeed = true,
            bool                    handleIgnorableWhitespace = true);

    virtual
    ~FormatterToText();

    MemoryManager&
    getMemoryManager()
    {
        return m_encoding.getMemoryManager();
    }

    Writer*
    getWriter() const
    {
        return m_writer;
    }

    void
    setWriter(Writer*   theWriter)
    {
        m_writer = theWriter;

        update(false);
    }

    void
    clearEncoding();

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

    void
    setEncoding(const XalanDOMString&   theEncoding)
    {
        m_encoding = theEncoding;

        update(false);
    }

    XalanDOMChar
    getMaxCharacter() const
    {
        return m_maxCharacter;
    }

    void
    setMaxCharacter(XalanDOMChar    theMaxChar)
    {
        m_maxCharacter = theMaxChar;
    }

    bool
    getNormalizeLinefeed() const
    {
        return m_normalize;
    }

    void
    setNormalizeLinefeed(bool   fNormalize)
    {
        m_normalize = fNormalize;
    }

    bool
    getHandleIgnorableWhitespace() const
    {
        return m_handleIgnorableWhitespace;
    }

    void
    setHandleIgnorableWhitespace(bool   fHandle)
    {
        m_handleIgnorableWhitespace = fHandle;
    }

    // These methods are inherited from FormatterListener ...

    virtual void
    setDocumentLocator(const Locator* const         locator);

    virtual void
    startDocument();

    virtual void
    endDocument();

    virtual void
    startElement(
            const XMLCh* const  name,
            AttributeListType&  attrs);

    virtual void
    endElement(const XMLCh* const   name);

    virtual void
    characters(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    charactersRaw(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    entityReference(const XMLCh* const  name);

    virtual void
    ignorableWhitespace(
            const XMLCh* const  chars,
            const size_type     length);

    virtual void
    processingInstruction(
            const XMLCh* const  target,
            const XMLCh* const  data);

    virtual void
    resetDocument();

    virtual void
    comment(const XMLCh* const  data);

    virtual void
    cdata(
            const XMLCh* const  ch,
            const size_type     length);

private:

    // These are not implemented.
    FormatterToText(const FormatterToText&);

    FormatterToText&
    operator=(const FormatterToText&);

    bool
    operator==(const FormatterToText&) const;

    // Utility function to update various member variables
    // when data changes.
    void
    update(bool fNormalizationOnly);

    // Data members...
    Writer*         m_writer;

    XalanDOMChar    m_maxCharacter;

    XalanDOMString  m_encoding;

    bool            m_haveEncoding;

    bool            m_normalize;

    bool            m_handleIgnorableWhitespace;

    const XalanDOMChar*         m_newlineString;

    XalanDOMString::size_type   m_newlineStringLength;
};


}


#endif  // FORMATTERTOTEXT_HEADER_GUARD_1357924680