xref: /trunk/main/autodoc/inc/udm/xml/xmlitem.hxx (revision 11c03c6d381fea19f0fea13ae5a371ba50bad241)

/**************************************************************
 *
 * 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.
 *
 *************************************************************/



#ifndef CSI_XML_XMLITEM_HXX
#define CSI_XML_XMLITEM_HXX

// USED SERVICES
    // BASE CLASSES
    // COMPONENTS
#include <cosv/tpl/swelist.hxx>
#include <cosv/tpl/dyn.hxx>
    // PARAMETERS

namespace csv
{
    class bostream;
}


namespace csi
{
namespace xml
{


/*  Basics:
    Item, Attribute, Element, TextContext
*/

class Item
{
  public:
    virtual             ~Item() {}
    void                WriteOut(
                            csv::bostream &     io_aFile ) const;
  private:
    virtual void        do_WriteOut(
                            csv::bostream &     io_aFile ) const = 0;
};

typedef csv::SweList_dyn< Item >            ItemList;

class Attribute
{
  public:
    virtual             ~Attribute() {}

    void                WriteOut(
                            csv::bostream &     io_aFile ) const;

    const ::csv::String& Name() const;
    const ::csv::String& Value() const;

  private:
    virtual const ::csv::String &
                        inq_Name() const = 0;
    virtual const ::csv::String &
                        inq_Value() const = 0;
};

typedef csv::SweList_dyn< Attribute >   AttrList;


class Element : public Item
{
  public:
    Element &           operator<<(             /// For multiple content items.
                            DYN Item *          let_dpItem );
    Element &           operator<<(             /// For multiple content items.
                            const ::csv::String& let_drText );
    Element &           operator<<(             /// For multiple content items.
                            const char *        let_dpText );
    Element &           operator<<(
                            DYN Attribute *     let_dpAttr );

    Element &           operator>>(             /// For multiple content items. @return the child Element.
                            DYN Element &       let_drElement );


    Item *              SetContent(             /// For only one content item.
                            DYN Item *          let_dpItem );       /// Replaces previous content. May be 0, then all content is deleted.
  private:
    // Interface Item:
    virtual void        do_WriteOut(
                            csv::bostream &     io_aFile ) const;
    // Local
    virtual void        op_streamout(
                            DYN Item *          let_dpItem ) = 0;
    virtual void        op_streamout(
                            DYN Attribute *     let_dpAttr ) = 0;

    virtual void        do_SetContent(
                            DYN Item *          let_dpItem ) = 0;
    // Helpers
    virtual const ::csv::String &
                        inq_TagName() const = 0;
    virtual const Item *
                        inq_Content() const = 0;
    virtual const AttrList *
                        inq_Attrs() const = 0;

    virtual bool        FinishEmptyTag_XmlStyle() const;    /// Defaulted to: true

    virtual bool        LineBreakAfterBeginTag() const;     /// Defaulted to: false
    virtual bool        LineBreakAfterEndTag() const;       /// Defaulted to: true, if LineBreakAfterBeginTag()
};

class TextContent : public Item
{
};


/*  Implementation simplifiers:
    EmptyElement, PureElement, SglTag
*/

class EmptyElement : public Element
{
  private:
    // Interface Element:
    virtual void        op_streamout(          /// does nothing
                            DYN Item *          let_dpItem );
    virtual void        op_streamout(
                            DYN Attribute *     let_dpAttr );
    virtual void        do_SetContent(          /// does nothing
                            DYN Item *          let_dpItem );
    virtual const Item *
                        inq_Content() const;    /// @return 0
    virtual const AttrList *
                        inq_Attrs() const;

    // Local
    virtual AttrList &  inq_RefAttrs() = 0;
};

class PureElement : public Element
{
  private:
    // Interface Element:
    virtual void        op_streamout(
                            DYN Item *          let_dpItem );
    virtual void        op_streamout(          /// does nothing
                            DYN Attribute *     let_dpAttr );
    virtual void        do_SetContent(
                            DYN Item *          let_dpItem );
    virtual const Item *
                        inq_Content() const;
    virtual const AttrList *
                        inq_Attrs() const;      /// @return 0
    // Local
    virtual Dyn< Item > &
                        inq_RefContent() = 0;
};

class SglTag : public Element
{
  private:
    // Interface Element:
    virtual void        op_streamout(          /// does nothing
                            DYN Item *          let_dpItem );
    virtual void        op_streamout(          /// does nothing
                            DYN Attribute *     let_dpAttr );
    virtual void        do_SetContent(          /// does nothing
                            DYN Item *          let_dpItem );
    virtual const Item *
                        inq_Content() const;    /// @return 0
    virtual const AttrList *
                        inq_Attrs() const;      /// @return 0
};



/*  Standard Element implementations, if there are not any
    specialized ones.
*/

class AnElement : public Element
{
  public:
                        AnElement(
                            const ::csv::String& i_sTagName );
                        AnElement(
                            const char *         i_sTagName );
                        ~AnElement();
  private:
    // Interface Element
    virtual void        op_streamout(
                            DYN Item *          let_dpItem );
    virtual void        op_streamout(
                            DYN Attribute *     let_dpAttr );
    virtual void        do_SetContent(
                            DYN Item *          let_dpItem );
    virtual const ::csv::String &
                        inq_TagName() const;
    virtual const Item *
                        inq_Content() const;
    virtual const AttrList *
                        inq_Attrs() const;
    // DATA
    ::csv::String       sTagName;
    Dyn< Item >         pContent;
    AttrList            aAttrs;
};


class AnEmptyElement : public EmptyElement
{
  public:
                        AnEmptyElement(
                            const ::csv::String & i_sTagName );
                        AnEmptyElement(
                            const char * i_sTagName );
                        ~AnEmptyElement();
  private:
    // Interface Element:
    virtual const ::csv::String &
                        inq_TagName() const;
    // Interface EmptyElement:
    virtual AttrList &  inq_RefAttrs();

    // DATA
    ::csv::String       sTagName;
    AttrList            aAttrs;
};

class APureElement : public PureElement
{
  public:
                        APureElement(
                            const ::csv::String &   i_sTagName );
                        APureElement(
                            const char *            i_sTagName );
                        ~APureElement();
  private:
    // Interface Element:
    virtual const ::csv::String &
                        inq_TagName() const;
    // Interface PureElement:
    virtual Dyn< Item > &
                        inq_RefContent();
    // DATA
    ::csv::String       sTagName;
    Dyn< Item >         pContent;
};

class ASglTag : public SglTag
{
  public:
                        ASglTag(
                            const ::csv::String & i_sTagName );
                        ASglTag(
                            const char *          i_sTagName );
                        ~ASglTag();
  private:
    // Interface Element:
    virtual const ::csv::String &
                        inq_TagName() const;
    // DATA
    ::csv::String         sTagName;
};


/* Standard Attribute implementation
*/
class AnAttribute : public Attribute
{
  public:
                        AnAttribute(
                            const ::csv::String & i_sName,
                            const ::csv::String & i_sValue );
                        AnAttribute(
                            const char *          i_sName,
                            const char *          i_sValue );
                        ~AnAttribute();
  private:
    // Interface Attribute:
    virtual const ::csv::String &
                        inq_Name() const;
    virtual const ::csv::String &
                        inq_Value() const;
    // DATA
    ::csv::String         sName;
    ::csv::String         sValue;
};



/*  Implementations of TextContent:

    Text        ( reserved characters will be replaced and appear unchanged )
    XmlCode     ( reserved characters stay and are interpreted
                  by the XML-viewer )
*/
class Text : public TextContent
{
  public:
                        Text(
                            const ::csv::String & i_sText );
                        Text(
                            const char *        i_sText );
                        ~Text();
  private:
    virtual void        do_WriteOut(
                            csv::bostream &     io_aFile ) const;
    // DATA
    ::csv::String         sText;
};


class XmlCode : public TextContent
{
  public:
                        XmlCode(
                            const ::csv::String & i_sText );
                        XmlCode(
                            const char *          i_sText );
                        ~XmlCode();
  private:
    virtual void        do_WriteOut(
                            csv::bostream &     io_aFile ) const;
    // DATA
    ::csv::String         sText;
};



// IMPLEMENTATION

inline void
Item::WriteOut( csv::bostream & io_aFile ) const
    { do_WriteOut(io_aFile); }

inline const ::csv::String &
Attribute::Name() const
    { return inq_Name(); }
inline const ::csv::String &
Attribute::Value() const
    { return inq_Value(); }

inline Element &
Element::operator<<( DYN Item * let_dpItem )
    { op_streamout(let_dpItem); return *this; }
inline Element &
Element::operator<<( const ::csv::String & let_drText )
    { op_streamout( new Text(let_drText) ); return *this; }
inline Element &
Element::operator<<( const char * let_drText )
    { op_streamout( new Text(let_drText) ); return *this; }
inline Element &
Element::operator<<( DYN Attribute * let_dpAttr )
    { op_streamout(let_dpAttr); return *this; }
inline Element &
Element::operator>>( DYN Element & let_drElement )
    { op_streamout(&let_drElement); return let_drElement; }
inline Item *
Element::SetContent( DYN Item * let_dpItem )
    { do_SetContent(let_dpItem); return let_dpItem; }


}   // namespace xml
}   // namespace csi

#endif