IXMLOutStream.h

//========================================================================================
// 
// $File$
// 
// Owner: Chris Parrish
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance 
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or 
// distribution of it requires the prior written permission of Adobe.
// 
//========================================================================================

#ifndef __IXMLOUTSTREAM__
#define __IXMLOUTSTREAM__

#include "XMLID.h"
#include "IPMUnknown.h"

#include "WideString.h"
#include "K2Vector.h"
#include "KeyValuePair.h"

class IPMStream;

class IXMLOutStream : public IPMUnknown
{
 public:
 
 enum { kDefaultIID = IID_IXMLOUTSTREAM };
 
 enum eEncodingType { kUTF8, kUTF16, kShiftJIS};

 enum eAttributeType { kCDATA, kNMTOKEN, kNMTOKENS, kENTITY, kENTITIES, kID, kIDREF, kIDREFS, kNOTATION, kEnumeration };

 enum eAttributeQualifier { kQNone, kQRequired, kQImplied, kQFixed };

 //=====================================================================================
 // CLASS : AttributeDfn
 //=====================================================================================
 class AttributeDfn {
 public:
 typedef object_type data_type;
 
 AttributeDfn()
 {}
 AttributeDfn(const WideString &n, eAttributeType t, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault()
 {}
 AttributeDfn(const WideString &n, eAttributeType t, const WideString &d, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault(d)
 {}
 AttributeDfn(const WideString &n, eAttributeType t, const UTF16TextChar *d, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault(d)
 {}
 AttributeDfn(const UTF16TextChar* n, eAttributeType t, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault()
 {}
 AttributeDfn(const UTF16TextChar* n, eAttributeType t, const WideString &d, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault(d)
 {}
 AttributeDfn(const UTF16TextChar* n, eAttributeType t, const UTF16TextChar* d, eAttributeQualifier q)
 : fName(n), fType(t), fQualifier(q), fDefault(d)
 {}
 AttributeDfn(const AttributeDfn &other)
 {Copy(other);}
 
 bool16 operator==(const AttributeDfn &other) const
 {return (fName == other.fName) && (fType == other.fType);}
 AttributeDfn& operator=(const AttributeDfn &other)
 {Copy(other); return *this;}
 
 private:
 void Copy(const AttributeDfn &other)
 {fName = other.fName; fType = other.fType; fQualifier = other.fQualifier; fDefault = other.fDefault;}
 
 public:
 WideString fName; 
 eAttributeType fType; 
 eAttributeQualifier fQualifier; 
 WideString fDefault; 
 };
 
 typedef K2Vector<AttributeDfn> AttributeDfnList;

 //=====================================================================================
 // CLASS : Attribute
 //=====================================================================================
 class Attribute {
 public:
 typedef object_type data_type;
 
 Attribute()
 {}
 Attribute(const WideString &n, const WideString &v)
 : fName(n), fValue(v)
 {}
 Attribute(const UTF16TextChar *n, const UTF16TextChar *v)
 : fName(n), fValue(v)
 {}
 Attribute(const Attribute &other)
 {Copy(other);}
 
 const WideString &GetName() const
 {return fName;}
 const WideString &GetValue() const
 {return fValue;}
 
 bool16 operator==(const Attribute &other) const
 {return (fName == other.fName) && (fValue == other.fValue);}
 Attribute& operator=(const Attribute &other)
 {Copy(other); return *this;}
 
 private:
 void Copy(const Attribute &other)
 {fName = other.fName; fValue = other.fValue;}
 
 public:
 WideString fName; 
 WideString fValue; 
 };
 
 typedef K2Vector<Attribute> AttributeList;

 typedef KeyValuePair<UTF16TextChar, const WideString* > Entity;

 typedef K2Vector<Entity> EntityMap;
 

 enum eContentParticleSeparator { kNone, kChoice, kSequence
 };

 enum eContentParticleOccurrence { kExactlyOnce, kOneOrMore, kZeroOrMore, kOptional
 };

 enum eKeyword { kKW_SPACE, kKW_PCDATA, kKW_ANY, kKW_EMPTY, kKW_REQUIRED, kKW_IMPLIED, kKW_FIXED, kKW_SYSTEM, kKW_PUBLIC, kKW_NDATA
 };
 

 //----- Stream

 virtual bool16 Open(eEncodingType encoding = kUTF16, bool16 stripInvalid = kTrue) = 0;

 virtual void Close() = 0;

 virtual ErrorCode Flush() = 0;
 

 //----- Standard elements and data 

 virtual void DocHeader(const WideString& version, bool16 standalone = kTrue) = 0;

 void DocHeader(const UTF16TextChar* version, bool16 standalone = kTrue)
 { this->DocHeader(WideString(version), standalone); }

 virtual void TextDeclaration(const WideString& version) = 0;

 void TextDeclaration(const UTF16TextChar* version)
 { this->TextDeclaration(WideString(version)); }

 virtual void DocType(const WideString& root, const WideString& URI) = 0;

 void DocType(const UTF16TextChar* root, const WideString& URI)
 { this->DocType(WideString(root), URI); }

 void DocType(const WideString& root, const UTF16TextChar* URI)
 { this->DocType(root, WideString(URI)); }

 void DocType(const UTF16TextChar* root, const UTF16TextChar* URI)
 { this->DocType(WideString(root), WideString(URI)); }

 virtual void DocType(const WideString& root, const WideString& name, const WideString& URI) = 0;

 virtual void BeginDocType(const WideString& root, bool16 newLine = kFalse) = 0;

 void BeginDocType(const UTF16TextChar* root, bool16 newLine = kFalse)
 { this->BeginDocType(WideString(root), newLine); }

 virtual void BeginDocType(const WideString& root, const WideString& systemIDLiteral, bool16 newLine = kFalse) = 0;

 virtual void BeginDocType(const WideString& root, const WideString& publicIDLiteral, const WideString& systemIDLiteral, bool16 newLine = kFalse) = 0;

 virtual void EndDocType(bool16 newLine = kFalse) = 0;

 virtual void WriteAttributeList(const WideString &elementName, const AttributeDfnList &dfns, bool16 newLine = kFalse) = 0;

 void WriteAttributeList(const UTF16TextChar* elementName, const AttributeDfnList &dfns, bool16 newLine = kFalse)
 { this->WriteAttributeList(WideString(elementName), dfns, newLine); }

 virtual void BeginElementTypeDecl(const WideString& elementName, bool16 newLine = kFalse) = 0;

 void BeginElementTypeDecl(const UTF16TextChar* elementName, bool16 newLine = kFalse)
 { this->BeginElementTypeDecl(WideString(elementName), newLine); }

 virtual void EndElementTypeDecl(bool16 newLine = kFalse) = 0;

 virtual void BeginContentModelDecl(eContentParticleSeparator separator = kNone, bool16 newLine = kFalse) = 0;

 virtual void EndContentModelDecl(eContentParticleOccurrence occurrence = kExactlyOnce, bool16 newLine = kFalse) = 0;

 virtual void BeginMixedContentModelDecl(eContentParticleSeparator separator = kNone, bool16 newLine = kFalse) = 0;

 virtual void EndMixedContentModelDecl(bool16 writeOccurrence = kTrue, bool16 newLine = kFalse) = 0;

 virtual void WriteSeparator(eContentParticleSeparator separator, bool16 newLine = kFalse) = 0;

 virtual void WriteContentParticle(const WideString& contentParticleName, eContentParticleOccurrence occurrence = kExactlyOnce, bool16 newLine = kFalse) = 0;

 void WriteContentParticle(const UTF16TextChar* contentParticleName, eContentParticleOccurrence occurrence = kExactlyOnce, bool16 newLine = kFalse)
 { this->WriteContentParticle(WideString(contentParticleName), occurrence, newLine); }

 virtual void WriteKeyword(eKeyword keyword, bool16 newLine = kFalse) = 0;

 virtual void BeginAttListDecl(const WideString& elementName, bool16 newLine = kFalse) = 0;

 void BeginAttListDecl(const UTF16TextChar* elementName, bool16 newLine = kFalse)
 { this->BeginAttListDecl(WideString(elementName), newLine); }

 virtual void EndAttListDecl(bool16 newLine = kFalse) = 0;

 virtual void WriteName(const WideString& name, bool16 newLine = kFalse) = 0;

 void WriteName(const UTF16TextChar* name, bool16 newLine = kFalse)
 { this->WriteName(WideString(name), newLine); }

 virtual void WriteAttributeType(eAttributeType attType, bool16 newLine = kFalse) = 0;

 virtual void WriteAttributeValue(const WideString& attValue, bool16 newLine = kFalse) = 0;

 void WriteAttributeValue(const UTF16TextChar* attValue, bool16 newLine = kFalse)
 { this->WriteAttributeValue(WideString(attValue), newLine); }

 virtual void BeginEntityDecl(const WideString& entityName, bool16 generalEntity = kTrue, bool16 newLine = kFalse) = 0;

 void BeginEntityDecl(const UTF16TextChar* entityName, bool16 generalEntity = kTrue, bool16 newLine = kFalse)
 { this->BeginEntityDecl(WideString(entityName), generalEntity, newLine); }

 virtual void EndEntityDecl(bool16 newLine = kFalse) = 0;

 virtual void BeginNotationDecl(const WideString& notationName, bool16 newLine = kFalse) = 0;

 void BeginNotationDecl(const UTF16TextChar* notationName, bool16 newLine = kFalse)
 { this->BeginNotationDecl(WideString(notationName), newLine); }

 virtual void EndNotationDecl(bool16 newLine = kFalse) = 0;

 virtual void WriteLiteral(const WideString& literal, bool16 wrapInQuotes = kFalse, bool16 newLine = kFalse) = 0;

 void WriteLiteral(const UTF16TextChar* literal, bool16 wrapInQuotes = kFalse, bool16 newLine = kFalse)
 { this->WriteLiteral(WideString(literal), wrapInQuotes, newLine); }

 virtual void Push(const WideString& tagName, bool16 newLine = kFalse) = 0;

 void Push(const UTF16TextChar* tagName, bool16 newLine = kFalse)
 { this->Push(WideString(tagName), newLine); }

 virtual void PushWithAttributes(const WideString& tagName, const AttributeList& attrs, bool16 newLine = kFalse) = 0;

 void PushWithAttributes(const UTF16TextChar* tagName, const AttributeList& attrs, bool16 newLine = kFalse)
 { this->PushWithAttributes(WideString(tagName), attrs, newLine); }

 virtual ErrorCode Pop(bool16 newLine = kFalse) = 0;

 virtual void Write(const WideString& data, bool16 newLine = kFalse, bool16 escape = kTrue) = 0;

 inline void Write(const UTF16TextChar* data, bool16 newLine = kFalse, bool16 escape = kTrue)
 { this->Write(WideString(data), newLine, escape); }

 virtual void WritePlatformText(IPMStream *data, int32 start, int32 count, bool16 newLine = kFalse, bool16 escape = kTrue) = 0;

 virtual void WriteEmpty(const WideString& tagName, bool16 newLine = kFalse) = 0;

 void WriteEmpty(const UTF16TextChar* tagName, bool16 newLine = kFalse)
 { this->WriteEmpty(WideString(tagName), newLine); }

 virtual void WriteEmptyWithAttributes(const WideString& tag, const AttributeList& attrs, bool16 newLine = kFalse) = 0;

 void WriteEmptyWithAttributes(const UTF16TextChar* tag, const AttributeList& attrs, bool16 newLine = kFalse)
 { this->WriteEmptyWithAttributes(WideString(tag), attrs, newLine); }
 

 virtual void Comment(const WideString& comment, bool16 newLine = kFalse) = 0;

 void Comment(const UTF16TextChar* comment, bool16 newLine = kFalse)
 { this->Comment(WideString(comment), newLine); }
 

 virtual void BeginCData(const WideString& data, bool16 escape = kFalse) = 0;

 void BeginCData(const UTF16TextChar* data, bool16 escape = kFalse)
 { this->BeginCData(WideString(data), escape); }
 
 virtual void EndCData(bool16 newLine = kTrue) = 0;
 

 virtual void BeginPI(const WideString& piTarget, const WideString& piData, bool16 newLine = kFalse, bool16 escape = kFalse) = 0;

 virtual void EndPI(bool16 newLine = kFalse) = 0;
 
 //----- Formatting

 virtual void IndentLevel(bool increase) = 0;

 virtual void Indent(bool on) = 0;

 virtual bool16 DoIndent(void) const = 0;

 virtual void WriteIndent(void) = 0;
 
 //----- Utility

 virtual bool CheckStatus() = 0; 

 virtual void ResetEntityMap(bool16 addStandardXMLEntity = kTrue) = 0;

 virtual void AppendEntityMap( EntityMap& map) = 0;
 
};

#endif //__IXMLOUTSTREAM__