[aaf-commits] AAF/ref-impl/src/OM OMXMLWriter.h, 1.1, 1.2 OMXMLWriter.cpp, 1.1, 1.2 OMXMLUtilities.h, 1.1, 1.2 OMXMLUtilities.cpp, 1.1, 1.2 OMXMLStorage.h, 1.1, 1.2 OMXMLStorage.cpp, 1.1, 1.2 OMXMLReader.h, 1.1, 1.2 OMXMLReader.cpp, 1.1, 1.2 OMWString.h, 1.1, 1.2 OMWString.cpp, 1.1, 1.2 OMSymbolspace.h, 1.1, 1.2 OMSymbolspace.cpp, 1.1, 1.2 OMByteArray.h, 1.1, 1.2 OMByteArray.cpp, 1.1, 1.2 OMXMLStoredStream.cpp, 1.14, 1.15 OMXMLStoredObjectFactory.cpp, 1.19, 1.20 OMXMLStoredObject.cpp, 1.43, 1.44 OMRootStorable.h, 1.13, 1.14 OMRootStorable.cpp, 1.19, 1.20 OMPropertyDefinition.cpp, 1.10, 1.11 OMDiskRawStorage.cpp, 1.36, 1.37 OMDictionary.cpp, 1.21, 1.22

[Philip de N. <ph...@us...>]

Update of /cvsroot/aaf/AAF/ref-impl/src/OM
In directory sc8-pr-cvs11.sourceforge.net:/tmp/cvs-serv28008/ref-impl/src/OM

Modified Files:
	OMXMLStoredStream.cpp OMXMLStoredObjectFactory.cpp 
	OMXMLStoredObject.cpp OMRootStorable.h OMRootStorable.cpp 
	OMPropertyDefinition.cpp OMDiskRawStorage.cpp OMDictionary.cpp 
Added Files:
	OMXMLWriter.h OMXMLWriter.cpp OMXMLUtilities.h 
	OMXMLUtilities.cpp OMXMLStorage.h OMXMLStorage.cpp 
	OMXMLReader.h OMXMLReader.cpp OMWString.h OMWString.cpp 
	OMSymbolspace.h OMSymbolspace.cpp OMByteArray.h 
	OMByteArray.cpp 
Log Message:
merge from aafx-prototype

Index: OMXMLStoredObjectFactory.cpp
===================================================================
RCS file: /cvsroot/aaf/AAF/ref-impl/src/OM/OMXMLStoredObjectFactory.cpp,v
retrieving revision 1.19
retrieving revision 1.20
diff -C2 -d -r1.19 -r1.20
*** OMXMLStoredObjectFactory.cpp	30 Nov 2004 19:29:35 -0000	1.19
--- OMXMLStoredObjectFactory.cpp	26 Mar 2007 16:00:52 -0000	1.20
***************
*** 1,5 ****
  //=---------------------------------------------------------------------=
  //
! // $Id$ $Name$
  //
  // The contents of this file are subject to the AAF SDK Public
--- 1,5 ----
  //=---------------------------------------------------------------------=
  //
! // $Id$
  //
  // The contents of this file are subject to the AAF SDK Public
***************
*** 29,34 ****
  #include "OMUtilities.h"
  #include "OMAssertions.h"
- #include "OMRawStorage.h"
  #include "OMDiskRawStorage.h"
  
  #include <ctype.h>
--- 29,35 ----
  #include "OMUtilities.h"
  #include "OMAssertions.h"
  #include "OMDiskRawStorage.h"
+ #include "OMExceptions.h"
+ 
  
  #include <ctype.h>
***************
*** 72,79 ****
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::openRead(OMRawStorage* rawStorage)
  {
    TRACE("OMXMLStoredObjectFactory::openRead");
!   return OMXMLStoredObject::openRead(rawStorage);
  }
  
--- 73,81 ----
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::openRead(OMRawStorage* /* rawStorage */)
  {
    TRACE("OMXMLStoredObjectFactory::openRead");
!   ASSERT("Unimplemented code not reached", false);
!   return 0;
  }
  
***************
*** 83,90 ****
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::openModify(OMRawStorage* rawStorage)
  {
    TRACE("OMXMLStoredObjectFactory::openModify");
!   return OMXMLStoredObject::openModify(rawStorage);
  }
  
--- 85,93 ----
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::openModify(OMRawStorage* /* rawStorage */)
  {
    TRACE("OMXMLStoredObjectFactory::openModify");
!   ASSERT("Unimplemented code not reached", false);
!   return 0;
  }
  
***************
*** 96,104 ****
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::createWrite(OMRawStorage* rawStorage,
!                                       const OMByteOrder byteOrder)
  {
    TRACE("OMXMLStoredObjectFactory::createWrite");
!   return OMXMLStoredObject::createWrite(rawStorage, byteOrder);
  }
  
--- 99,108 ----
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::createWrite(OMRawStorage* /* rawStorage */,
!                                       const OMByteOrder /* byteOrder */)
  {
    TRACE("OMXMLStoredObjectFactory::createWrite");
!   ASSERT("Unimplemented code not reached", false);
!   return 0;
  }
  
***************
*** 110,118 ****
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::createModify(OMRawStorage* rawStorage,
!                                        const OMByteOrder byteOrder)
  {
    TRACE("OMXMLStoredObjectFactory::createModify");
!   return OMXMLStoredObject::createModify(rawStorage, byteOrder);
  }
  
--- 114,123 ----
    //   @rdesc An <c OMXMLStoredObject> representing the root object.
  OMStoredObject*
! OMXMLStoredObjectFactory::createModify(OMRawStorage* /* rawStorage */,
!                                        const OMByteOrder /* byteOrder */)
  {
    TRACE("OMXMLStoredObjectFactory::createModify");
!   ASSERT("Unimplemented code not reached", false);
!   return 0;
  }
  
***************
*** 123,132 ****
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::openRead(const wchar_t* /* fileName */)
  {
    TRACE("OMXMLStoredObjectFactory::openRead");
!   ASSERT("Unimplemented code not reached", false);
! //return OMXMLStoredObject::openRead(fileName);
!   return 0;
  }
  
--- 128,142 ----
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::openRead(const wchar_t* fileName )
  {
    TRACE("OMXMLStoredObjectFactory::openRead");
! #if !defined(HAVE_EXPAT)
!     ASSERT("Expat library available", false);
!     return 0;
! #else
! 
!   OMDiskRawStorage* storage = OMDiskRawStorage::openExistingRead(fileName);
!   return OMXMLStoredObject::openRead(storage);
! #endif  
  }
  
***************
*** 137,146 ****
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::openModify(const wchar_t* /* fileName */)
  {
    TRACE("OMXMLStoredObjectFactory::openModify");
!   ASSERT("Unimplemented code not reached", false);
! //return OMXMLStoredObject::openModify(fileName);
!   return 0;
  }
  
--- 147,161 ----
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::openModify(const wchar_t* fileName)
  {
    TRACE("OMXMLStoredObjectFactory::openModify");
! #if !defined(HAVE_EXPAT)
!     ASSERT("Expat library available", false);
!     return 0;
! #else
! 
!   OMDiskRawStorage* storage = OMDiskRawStorage::openExistingModify(fileName);
!   return OMXMLStoredObject::openModify(storage);
! #endif  
  }
  
***************
*** 153,162 ****
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::createModify(const wchar_t* NNAME(fileName),
!                                        const OMByteOrder NNAME(byteOrder))
  {
    TRACE("OMXMLStoredObjectFactory::createModify");
!   ASSERT("Unimplemented code not reached", false);
!   return 0;
  }
  
--- 168,183 ----
    //          the disk file.
  OMStoredObject*
! OMXMLStoredObjectFactory::createModify(const wchar_t* fileName,
!                                        const OMByteOrder byteOrder)
  {
    TRACE("OMXMLStoredObjectFactory::createModify");
! #if !defined(HAVE_EXPAT)
!     ASSERT("Expat library available", false);
!     return 0;
! #else
! 
!   OMDiskRawStorage* storage = OMDiskRawStorage::openNewModify(fileName);
!   return OMXMLStoredObject::createModify(storage);
! #endif  
  }
  
***************
*** 174,178 ****
    TRACE("OMXMLStoredObjectFactory::creatWrite");
    ASSERT("Unimplemented code not reached", false);
- //return OMXMLStoredObject::createWrite(fileName, byteOrder);
    return 0;
  }
--- 195,198 ----
***************
*** 186,189 ****
--- 206,214 ----
  {
    TRACE("OMXMLStoredObjectFactory::isRecognized");
+   
+ #if !defined(HAVE_EXPAT)
+     return false;
+ #else
+ 
    bool result;
    OMRawStorage* rawStorage = OMDiskRawStorage::openExistingRead(fileName);
***************
*** 195,198 ****
--- 220,224 ----
    }
    return result;
+ #endif  
  }
  
***************
*** 208,228 ****
    PRECONDITION("Positionable raw storage", rawStorage->isPositionable());
  
!   char signature[] = "<?XML VERSION=\"1.0\"?>"
!   "<?OM SIGNATURE=\"{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}\"?>";
!   char* p = strchr(signature, '{');
!   ASSERT("Found place holder", p != 0);
!   toString(encoding(), p);
!   size_t bufferSize = strlen(signature) + 1;
!   char* buffer = new char[bufferSize];
!   ASSERT("Valid heap pointer", buffer != 0);
!   bool result = readSignature(rawStorage, buffer, bufferSize);
!   if (result) {
!     if (strcmp(signature, buffer) != 0) {
!       result = false;
      }
    }
!   delete [] buffer;
    rawStorage->setPosition(0);
!   return result;
  }
  
--- 234,264 ----
    PRECONDITION("Positionable raw storage", rawStorage->isPositionable());
  
! #if !defined(HAVE_EXPAT)
!     return false;
! #else
! 
!   bool isRecog = false;
!   OMXMLReader* reader = 0;
!   try
!   {
!     reader = OMXMLReader::create(rawStorage);
!     if (reader->nextElement() &&
!           reader->elementEquals(OMSymbolspace::getBaselineURI(), L"AAF"))
!     {
!         isRecog = true;
      }
    }
!   catch (...)
!   {}
! 
!   if (reader != 0)
!   {
!     delete reader;
!   }
!   
    rawStorage->setPosition(0);
!   
!   return isRecog;
! #endif  
  }
  
***************
*** 238,245 ****
  {
    TRACE("OMXMLStoredObjectFactory::compatibleRawStorage");
! 
!   // tjb -- missing checks ?
!   bool result = true;
!   return result;
  }
  
--- 274,279 ----
  {
    TRACE("OMXMLStoredObjectFactory::compatibleRawStorage");
!   // raw storage is not supported
!   return false;
  }
  
***************
*** 253,261 ****
    TRACE("OMXMLStoredObjectFactory::compatibleNamedFile");
  
!   // Directly accessed named files are not supported regardless of the
!   // access mode. Named files are supported via a disk file based
!   // implementation of OMRawStorage.
!   bool result = false;
!   return result;
  }
  
--- 287,291 ----
    TRACE("OMXMLStoredObjectFactory::compatibleNamedFile");
  
!   return true;
  }
  
***************
*** 284,312 ****
    //   @parm TBS
    //   @parm TBS
! bool OMXMLStoredObjectFactory::readSignature(OMRawStorage* rawStorage,
!                                              char* signature,
!                                              size_t signatureSize)
  {
    TRACE("OMXMLStoredObjectFactory::readSignature");
!   size_t index = 0;
!   while (index < signatureSize - 1) {
!     unsigned char ch;
!     OMUInt32 bytesRead;
!     rawStorage->read(reinterpret_cast<OMByte*>(&ch), 1, bytesRead);
!     if (bytesRead != 1) {
!       break;
!     }
!     int c = ch;
!     if (isprint(c)) {
!       signature[index++] = toupper(ch);
!     }
!   }
!   bool result;
!   if (index == (signatureSize - 1)) {
!   signature[index] = 0;
!     result = true;
!   } else {
!     result = false;
!   }
!   return result;
  }
--- 314,323 ----
    //   @parm TBS
    //   @parm TBS
! bool OMXMLStoredObjectFactory::readSignature(OMRawStorage* /* rawStorage */,
!                                              char* /* signature */,
!                                              OMUInt32 /* signatureSize */)
  {
    TRACE("OMXMLStoredObjectFactory::readSignature");
!   ASSERT("Unimplemented code not reached", false);
!   return false;
  }

Index: OMXMLStoredObject.cpp
===================================================================
RCS file: /cvsroot/aaf/AAF/ref-impl/src/OM/OMXMLStoredObject.cpp,v
retrieving revision 1.43
retrieving revision 1.44
diff -C2 -d -r1.43 -r1.44
*** OMXMLStoredObject.cpp	23 Feb 2007 23:58:42 -0000	1.43
--- OMXMLStoredObject.cpp	26 Mar 2007 16:00:52 -0000	1.44
***************
*** 1,5 ****
  //=---------------------------------------------------------------------=
  //
! // $Id$ $Name$
  //
  // The contents of this file are subject to the AAF SDK Public
--- 1,5 ----
  //=---------------------------------------------------------------------=
  //
! // $Id$
  //
[...4570 lines suppressed...]
!             }
!         }
!         else
!         {
!             getReader()->skipContent();
!         }
!     }
! 
!     
!     
!     // return the reader to the <Header> element
!     getReader()->reset();
!     getReader()->nextElement();
!     while (getReader()->nextElement() && 
!         !getReader()->elementEquals(getBaselineURI(), L"Header"))
!     {
!         getReader()->skipContent();
!     }
!     
  }

--- NEW FILE: OMXMLReader.h ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLReader.h,v 1.2 2007/03/26 16:00:53 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
// Licensor of the AAF Association is British Broadcasting Corporation.
// All rights reserved.
//
//=---------------------------------------------------------------------=


#ifndef __OMXMLREADER_H__
#define __OMXMLREADER_H__

#include "OMRawStorage.h"
#include "OMWString.h"
#include "OMList.h"
#include "OMListIterator.h"
#include "OMVector.h"


class OMXMLAttribute
{
public:
    OMXMLAttribute(const wchar_t* nmspace, const wchar_t* localName, const wchar_t* value);
    ~OMXMLAttribute();

    const wchar_t* getNamespace() const;
    const wchar_t* getLocalName() const;
    const wchar_t* getValue() const;

private:
    OMWString       _nmspace;
    OMWString       _localName;
    OMWString       _value;
};


class OMXMLReader
{
public:
    static OMXMLReader* create(OMRawStorage* xmlStream);
    
    virtual ~OMXMLReader();

    enum EventType
    {
        NONE,
        NOTATION_DECL,
        UNPARSED_ENTITY_DECL,
        START_PREFIX_MAPPING,
        END_PREFIX_MAPPING,
        START_ELEMENT,
        END_ELEMENT,
        CHARACTERS
    };

    virtual bool next() = 0;
    virtual void reset() = 0;
    
    virtual EventType getEventType() = 0;
    virtual void getNotationDecl(const wchar_t*& name, const wchar_t*& publicID, 
        const wchar_t*& systemID) = 0;
    virtual void getUnparsedEntityDecl(const wchar_t*& name, const wchar_t*& publicID, 
        const wchar_t*& systemID, const wchar_t*& notationName) = 0;
    virtual void getStartPrefixMapping(const wchar_t*& prefix, const wchar_t*& uri) = 0;
    virtual void getEndPrefixMapping(const wchar_t*& prefix) = 0;
    virtual void getStartElement(const wchar_t*& uri, const wchar_t*& localName, 
        const OMList<OMXMLAttribute*>*& attributes) = 0;
    virtual void getEndElement(const wchar_t*& uri, const wchar_t*& localName) = 0;
    virtual void getCharacters(const wchar_t*& data, OMUInt32& length) = 0;

    virtual const wchar_t* getPositionString() = 0;
    
public:
    // utility functions
    bool nextElement();
    bool nextEndElement();
    bool moveToEndElement();
    void skipContent();
    bool elementEquals(const wchar_t* uri, const wchar_t* localName);
    OMXMLAttribute* getAttribute(const OMList<OMXMLAttribute*>* attributes,
        const wchar_t* nmspace, const wchar_t* localName);
};



#if defined(HAVE_EXPAT)

#include <expat.h>


class OMXMLReaderExpat : public OMXMLReader
{
public:
    OMXMLReaderExpat(OMRawStorage* xmlStream);
    virtual ~OMXMLReaderExpat();

    virtual bool next();
    virtual void reset();
    
    virtual EventType getEventType();
    virtual void getNotationDecl(const wchar_t*& name, const wchar_t*& publicID, 
        const wchar_t*& systemID);
    virtual void getUnparsedEntityDecl(const wchar_t*& name, const wchar_t*& publicID, 
        const wchar_t*& systemID, const wchar_t*& notationName);
    virtual void getStartPrefixMapping(const wchar_t*& prefix, const wchar_t*& uri);
    virtual void getEndPrefixMapping(const wchar_t*& prefix);
    virtual void getStartElement(const wchar_t*& uri, const wchar_t*& localName, 
        const OMList<OMXMLAttribute*>*& attributes);
    virtual void getEndElement(const wchar_t*& uri, const wchar_t*& localName);
    virtual void getCharacters(const wchar_t*& data, OMUInt32& length);

    virtual const wchar_t* getPositionString();

    
public:
    void notationDeclHandler(const XML_Char* notationName, const XML_Char* base,
        const XML_Char* systemId, const XML_Char* publicId);
    void entityDeclHandler(const XML_Char* entityName, 
        int is_parameter_entity, const XML_Char* value, int value_length, 
        const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId, 
        const XML_Char* notationName);
    void startNamespaceDeclHandler(const XML_Char* prefix, const XML_Char* uri);
    void endNamespaceDeclHandler(const XML_Char* prefix);
    void startElementHandler(const XML_Char* name, const XML_Char** atts);
    void endElementHandler(const XML_Char* name);
    void characterDataHandler(const XML_Char* s, int len);
    
private:
    void registerEvent(EventType event);
    EventType nextEvent(void);
    void clearEvents(void);
    void setCharacterData(const wchar_t* data);

    OMUInt32 readNextChunk(void* buffer, OMUInt32 num);
    OMUInt32 readCharacters(wchar_t* out, const XML_Char* in, wchar_t terminator);
    OMUInt32 xmlStringLen(const XML_Char* s) const;

    wchar_t* getWorkBuffer(OMUInt32 len);
    wchar_t* getWorkBuffer(void);
    OMUInt32 getWorkBufferSize(void);

    const char* getErrorString();
    
    OMVector<EventType>  _events;
    EventType        _event;
    OMWString        _name;
    OMWString        _publicID;
    OMWString        _systemID;
    OMWString        _notationName;
    OMWString        _base;
    OMWString        _uri;
    OMWString        _localName;
    OMList<OMXMLAttribute*>   _attributes;
    OMWString        _data;
    OMWString        _prefix;
    OMWString        _prefixUri;

    bool             _appendData;
    
    struct QName
    {
        OMWString uri;
        OMWString prefix;
    };
    OMVector<QName*>    _startNmspaceDecls;
    OMVector<OMWString> _endNmspaceDecls;
    
    OMWString   _positionString;
    char _errorString[512];

    OMRawStorage* _xmlStream;
    XML_Parser  _parser;
    bool        _readNextChunk;
    bool        _status;
    OMUInt32    _numInBuffer;
    wchar_t*    _workBuffer;
    OMUInt32    _workBufferSize;
};

// expat handlers
void expat_NotationDeclHandler(void* userData, const XML_Char* notationName,
    const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId);
void expat_EntityDeclHandler(void* userData, const XML_Char* entityName, 
    int is_parameter_entity, const XML_Char* value, int value_length, 
    const XML_Char* base, const XML_Char* systemId, const XML_Char* publicId, 
    const XML_Char* notationName);
void expat_StartNamespaceDeclHandler(void* userData, const XML_Char* prefix,
    const XML_Char* uri);
void expat_EndNamespaceDeclHandler(void* userData, const XML_Char *prefix);
void expat_StartElementHandler(void* userData, const XML_Char* name, const XML_Char** atts);
void expat_EndElementHandler(void* userData, const XML_Char* name);
void expat_CharacterDataHandler(void* userData, const XML_Char* s, int len);


#endif // HAVE_EXPAT


#endif

Index: OMRootStorable.h
===================================================================
RCS file: /cvsroot/aaf/AAF/ref-impl/src/OM/OMRootStorable.h,v
retrieving revision 1.13
retrieving revision 1.14
diff -C2 -d -r1.13 -r1.14
*** OMRootStorable.h	27 Feb 2004 14:26:43 -0000	1.13
--- OMRootStorable.h	26 Mar 2007 16:00:55 -0000	1.14
***************
*** 84,87 ****
--- 84,89 ----
    static const OMClassId _rootClassId;
  
+   void setDictionary(OMDictionary* dictionary);
+   
  private:
  

--- NEW FILE: OMXMLUtilities.h ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLUtilities.h,v 1.2 2007/03/26 16:00:51 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2005, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
// Licensor of the AAF Association is British Broadcasting Corporation.
// All rights reserved.
//
//=---------------------------------------------------------------------=

#ifndef __OMXMLUTILITIES_H__
#define __OMXMLUTILITIES_H__

#include "OMDataTypes.h"
#include "OMByteArray.h"


#define XML_MAX_AUID_URI_SIZE                   46
#define XML_MAX_MOBID_URI_SIZE                  79
// XML_MAX_URI_SIZE = max(XML_MAX_AUID_URI_SIZE, XML_MAX_MOBID_URI_SIZE)
#define XML_MAX_URI_SIZE                        79 
#define XML_MAX_INTEGER_STRING_SIZE             21
#define XML_MAX_BYTE_ORDER_STRING_SIZE          13
#define XML_MAX_TIMESTAMP_STRING_SIZE           32
#define XML_MAX_TIMESTRUCT_STRING_SIZE          17
#define XML_MAX_DATESTRUCT_STRING_SIZE          16
#define XML_MAX_BOOL_STRING_SIZE                6
#define XML_MAX_RATIONAL_STRING_SIZE            24
#define XML_MAX_VERSIONTYPE_STRING_SIZE         10


#if defined (_MSC_VER)
#define std_swprintf _snwprintf
#else
#define std_swprintf swprintf
#endif


#ifdef _MSC_VER			// MS VC++ dosen't provide POSIX strncasecmp
#define strncasecmp(s1, s2, n) strnicmp(s1, s2, n)
#else
#include <strings.h>	// strncasecmp()
#endif


int utf8CodeLen(const char* u8Code);
int utf16CodeLen(const wchar_t* u16Code);
int utf16CodeLen(const char* u8Code);
int utf8CodeLen(const wchar_t* u16Code);
int utf8CodeToUTF16(wchar_t* u16Code, const char* u8Code, int* u8Len, int* u16Len);
int utf16CodeToUTF8(char* u8Code, const wchar_t* u16Code, int* u16Len, int* u8Len);
long utf16StrLen(const char* u8str);
long utf8StrLen(const wchar_t* u16str);
wchar_t* utf8ToUTF16(const char* u8str);
void utf8ToUTF16(wchar_t* u16str, const char* u8str, OMUInt32 u16Size);
char* utf16ToUTF8(const wchar_t* u16str);
void utf16ToUTF8(char* u8str, const wchar_t* u16str, OMUInt32 u8Size);
bool isValidCodePoint(OMUInt32 code);
void codePointToUTF16(OMUInt32 code, wchar_t** u16Str);
OMUInt32 codePoint(const char* u8Code);
OMUInt32 codePoint(const wchar_t* u16Code);


void auidToURI(OMUniqueObjectIdentification id, wchar_t* uri);
void mobIdToURI(OMMaterialIdentification mobId, wchar_t* uri);

bool isQSymbol(const wchar_t* str);
bool isAUIDURI(const wchar_t* str);
bool isUMIDURI(const wchar_t* str);
void uriToAUID(const wchar_t* uri, OMUniqueObjectIdentification* id);
void uriToMobId(const wchar_t* uri, OMMaterialIdentification* mobId);

void integerToString(const OMByte* value, OMUInt8 size, bool isSigned, wchar_t* str, bool hex = false);
void byteOrderToString(OMByteOrder byteOrder, wchar_t* str);
void headerByteOrderToString(const OMByte* internalBytes, wchar_t* str);
void timeStampToString(const OMByte* internalBytes, wchar_t* str);
void timeStructToString(const OMByte* internalBytes, wchar_t* str);
void dateStructToString(const OMByte* internalBytes, wchar_t* str);
void boolToString(bool value, wchar_t* str);
void rationalToString(const OMByte* internalBytes, wchar_t* str);
void versionTypeToString(const OMByte* internalBytes, wchar_t* str);

void integerFromString(OMByteArray& bytes, const wchar_t* str, OMUInt8 size, bool isSigned);
void mobIdFromString(OMByteArray& bytes, const wchar_t* str);
void auidFromString(OMByteArray& bytes, const wchar_t* str);
void timeStructFromString(OMByteArray& bytes, const wchar_t* str);
void dateStructFromString(OMByteArray& bytes, const wchar_t* str);
void timeStampFromString(OMByteArray& bytes, const wchar_t* str);
void byteOrderFromString(OMByteArray& bytes, const wchar_t* str);
void byteArrayFromString(OMByteArray& bytes, const wchar_t* str);
void rationalFromString(OMByteArray& bytes, const wchar_t* str);
void versionTypeFromString(OMByteArray& bytes, const wchar_t* str);

void byteOrderFromString(const wchar_t* str, OMByteOrder* byteOrder);
void headerByteOrderFromString(OMByteArray& bytes, const wchar_t* str);
void boolFromString(const wchar_t* str, bool& value);
void uint16FromString(const wchar_t* str, OMUInt16& value);
void int64FromString(const wchar_t* str, OMInt64& value);
void uint32FromString(const wchar_t* str, OMUInt32& value);
void uint8FromString(const wchar_t* str, OMUInt8& value);


bool stringRequiresEscaping(const wchar_t* str);
bool characterRequiresEscaping(OMUInt32 code);
wchar_t* escapeString(const wchar_t* str);
wchar_t* escapeCharacter(const wchar_t c);
wchar_t* unescapeString(const wchar_t* str);
wchar_t unescapeCharacter(const wchar_t* cstr);

wchar_t* wideCharacterStringDup(const wchar_t* str);

bool fileExists(const wchar_t* fileName);
int wmkdir(const wchar_t* dirpath);

bool isRelativePath(const wchar_t* filepath);
bool isFileURL(const wchar_t* uri);
bool isRelativeURI(const wchar_t* uri);
wchar_t* getBaseFilePath(const wchar_t* filepath);

void wcsconvertURItoFilepath(const wchar_t *uri, wchar_t *filepath);
void wcsconvertFilepathtoURI(const wchar_t *filepath, wchar_t *uri);


#endif 

--- NEW FILE: OMXMLWriter.cpp ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLWriter.cpp,v 1.2 2007/03/26 16:00:50 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2005, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
// Licensor of the AAF Association is British Broadcasting Corporation.
// All rights reserved.
//
//=---------------------------------------------------------------------=

#include "OMXMLWriter.h"
#include "OMXMLUtilities.h"
#include "OMVectorIterator.h"
#include "OMSetIterator.h"
#include "OMExceptions.h"
#include "OMAssertions.h"


static const wchar_t* g_internalDefaultNamespacePrefix = L" ";
static const wchar_t* g_emptyString = L"";


OMXMLWriter*
OMXMLWriter::create(OMRawStorage* xmlStream)
{
    TRACE("OMXMLWriter::create");
    
    return new OMXMLWriterSimple(xmlStream);
}


OMXMLWriterSimple::OMXMLWriterSimple(OMRawStorage* xmlStream)
{
    TRACE("OMXMLWriterSimple::OMXMLWriterSimple(OMRawStorage)");
    
    initialise(xmlStream, UTF8, LE);
}

OMXMLWriterSimple::OMXMLWriterSimple(OMRawStorage* xmlStream, XMLUTF16ByteOrder byteOrder)
{
    TRACE("OMXMLWriterSimple::OMXMLWriterSimple(OMRawStorage, XMLUTF16ByteOrder)");
    
    initialise(xmlStream, UTF16, byteOrder);
}

OMXMLWriterSimple::~OMXMLWriterSimple()
{
    TRACE("OMXMLWriterSimple::~OMXMLWriterSimple");
    
    OMUInt32 elementCount = _elementStack.count();
    for (OMUInt32 i = 0; i < elementCount; i++)
    {
        writeElementEnd();
    }
}

void
OMXMLWriterSimple::initialise(OMRawStorage* xmlStream, XMLEncoding encoding, 
    XMLUTF16ByteOrder byteOrder)
{
    TRACE("OMXMLWriterSimple::initialise");
    
    _encoding = encoding;
    _byteOrder = byteOrder;

    _swap = false;
    if (encoding == UTF16)
    {
        OMUInt16 test = 0xFFFE;
        OMByte firstByte = *((OMByte*)&test);
        if (firstByte == 0xFF && byteOrder == LE)
        {
            _swap = true;
        }
        else if (byteOrder == BE)
        {
            _swap = true;
        }
    }

    _prevWriteType = NONE;
    _xmlStream = xmlStream;
    _level = 0;
}

void 
OMXMLWriterSimple::writeDocumentStart(void)
{
    TRACE("OMXMLWriterSimple::writeDocumentStart");
    PRECONDITION("Valid state", _prevWriteType == NONE);
    
    writeProlog();
    
    _prevWriteType = START;
}

void 
OMXMLWriterSimple::writeDocumentEnd(void)
{
    TRACE("OMXMLWriterSimple::writeDocumentEnd");

    OMUInt32 elementCount = _elementStack.count();
    for (OMUInt32 i = 0; i < elementCount; i++)
    {
        writeElementEnd();
    }

    _prevWriteType = END;
}

void
OMXMLWriterSimple::writeElementStart(const wchar_t* ns, const wchar_t* localName)
{
    TRACE("OMXMLWriterSimple::writeElementStart");
    PRECONDITION("Valid state", _prevWriteType == START ||
        _prevWriteType == ELEMENT_START ||
        _prevWriteType == DELAYED_ELEMENT_START ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END ||
        _prevWriteType == ELEMENT_CONTENT ||
        _prevWriteType == ELEMENT_END || 
        _prevWriteType == COMMENT ||
        _prevWriteType == PROC_INSTRUCTION);
    
    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    if (_prevWriteType == ELEMENT_START || _prevWriteType == ATTRIBUTE_END)
    {
        write(L">\n", 2);
    }

    Element* parentElement = 0;
    if (_elementStack.count() > 0)
    {
        parentElement = _elementStack.getAt(_elementStack.count() - 1);
    }
    Element* element = new Element(parentElement, ns, localName);
    _elementStack.append(element);

    const wchar_t* prefix = element->getPrefix(ns);
    if (wcslen(prefix) == 0)
    {
        _prevWriteType = DELAYED_ELEMENT_START;
        return;
    }

    writeIndent(_level);
    write(L"<", 1);
    if (wcscmp(prefix, g_internalDefaultNamespacePrefix) != 0)
    {
        writeName(prefix, wcslen(prefix));
        write(L":", 1);
    }
    writeName(localName, wcslen(localName));

    _level++;
    _prevWriteType = ELEMENT_START;
}

void
OMXMLWriterSimple::declareNamespace(const wchar_t* ns, const wchar_t* prefix)
{
    TRACE("OMXMLWriterSimple::declareNamespace");
    PRECONDITION("Valid state", _prevWriteType == DELAYED_ELEMENT_START || 
        _prevWriteType == ELEMENT_START ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END);
    PRECONDITION("Valid prefix", prefix == 0 || validPrefix(prefix));
    PRECONDITION("Valid namespace", validNamespace(ns));

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    ASSERT("Elements count not zero", _elementStack.count() > 0);
    Element* element = _elementStack.getAt(_elementStack.count() - 1);
    bool wasAdded;
    if (prefix == OMXMLWRITER_DEFAULT_NAMESPACE_PREFIX)
    {
        wasAdded = element->addNamespaceDecl(ns, g_internalDefaultNamespacePrefix);
    }
    else
    {
        wasAdded = element->addNamespaceDecl(ns, prefix);
    }

    if (wasAdded)
    {
        if (_prevWriteType == DELAYED_ELEMENT_START)
        {
            ASSERT("Namespace declarations must start with the current element", 
                wcscmp(ns, element->getNamespace()) == 0);
            
            writeIndent(_level);
            write(L"<", 1);
            if (prefix != OMXMLWRITER_DEFAULT_NAMESPACE_PREFIX)
            {
                writeName(prefix, wcslen(prefix));
                write(L":", 1);
            }
            writeName(element->getLocalName(), wcslen(element->getLocalName()));

            _level++;
            _prevWriteType = ELEMENT_START;
        }

        write(L" xmlns", 6);
        if (prefix != OMXMLWRITER_DEFAULT_NAMESPACE_PREFIX)
        {
            write(L":",1);
            writeName(prefix, wcslen(prefix));
        }
        write(L"=\"", 2);
        writeAttributeData(ns, wcslen(ns));
        write(L"\"", 1);
    }
}

void
OMXMLWriterSimple::writeAttribute(const wchar_t* ns, const wchar_t* localName, const wchar_t* value)
{
    TRACE("OMXMLWriterSimple::writeAttribute");
    PRECONDITION("Valid state", _prevWriteType == ELEMENT_START || 
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END);

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    write(L" ", 1);

    if (ns != 0)
    {
        const wchar_t* prefix = getNonDefaultNSPrefix(ns);
        ASSERT("Valid prefix", prefix != 0 && wcslen(prefix) > 0);
        writeName(prefix, wcslen(prefix));
        write(L":", 1);
    }

    writeName(localName, wcslen(localName));
    write(L"=\"", 2);
    writeAttributeData(value, wcslen(value));
    write(L"\"", 1);

    _prevWriteType = ATTRIBUTE_END;
}

void 
OMXMLWriterSimple::writeAttributeStart(const wchar_t* ns, const wchar_t* localName)
{
    TRACE("OMXMLWriterSimple::writeAttributeStart");
    PRECONDITION("Valid state", _prevWriteType == ELEMENT_START || 
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END);
        
    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    write(L" ", 1);

    if (ns != 0)
    {
        const wchar_t* prefix = getNonDefaultNSPrefix(ns);
        ASSERT("Valid prefix", prefix != 0 && wcslen(prefix) > 0);
        writeName(prefix, wcslen(prefix));
        write(L":", 1);
    }

    writeName(localName, wcslen(localName));
    write(L"=\"", 2);

    _prevWriteType = ATTRIBUTE_START;
}

void 
OMXMLWriterSimple::writeAttributeContent(const wchar_t* value)
{
    TRACE("OMXMLWriterSimple::writeAttributeContent");
    PRECONDITION("Valid state", _prevWriteType == ATTRIBUTE_START || 
        _prevWriteType == ATTRIBUTE_CONTENT);
    
    writeAttributeData(value, wcslen(value));

    _prevWriteType = ATTRIBUTE_CONTENT;
}

void 
OMXMLWriterSimple::writeAttributeEnd(void)
{
    TRACE("OMXMLWriterSimple::writeAttributeEnd");
    PRECONDITION("Valid state", _prevWriteType == ATTRIBUTE_START || 
        _prevWriteType == ATTRIBUTE_CONTENT);
    
    write(L"\"", 1);

    _prevWriteType = ATTRIBUTE_END;
}

void
OMXMLWriterSimple::writeElementContent(const wchar_t* content, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeElementContent");
    PRECONDITION("Valid state", _prevWriteType == ELEMENT_START ||
        _prevWriteType == ELEMENT_END ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END ||
        _prevWriteType == ELEMENT_CONTENT);

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    if (_prevWriteType == ELEMENT_START || _prevWriteType == ATTRIBUTE_END)
    {
        write(L">", 1);
    }

    writeElementData(content, length);

    _prevWriteType = ELEMENT_CONTENT;
}

void
OMXMLWriterSimple::writeElementEnd()
{
    TRACE("OMXMLWriterSimple::writeElementEnd");
    PRECONDITION("Valid state", _prevWriteType == ELEMENT_START ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END ||
        _prevWriteType == ELEMENT_CONTENT ||
        _prevWriteType == ELEMENT_END || 
        _prevWriteType == COMMENT ||
        _prevWriteType == PROC_INSTRUCTION);

    _level--;

    ASSERT("Elements count not zero", _elementStack.count() > 0);
    Element* element = _elementStack.getAt(_elementStack.count() - 1);
    const wchar_t* prefix = element->getPrefix();
    ASSERT("Valid prefix", prefix != 0 && wcslen(prefix) > 0);

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    if (_prevWriteType == ELEMENT_START || _prevWriteType == ATTRIBUTE_END)
    {
        write(L"/>\n", 3);
    }
    else
    {
        if (_prevWriteType != ELEMENT_CONTENT)
        {
            if (_prevWriteType != ELEMENT_END && 
                _prevWriteType != COMMENT &&
                _prevWriteType != PROC_INSTRUCTION)
            {
                write(L"\n", 1);
            }
            writeIndent(_level);
        }

        write(L"</", 2);
        if (wcscmp(prefix, g_internalDefaultNamespacePrefix) != 0)
        {
            writeName(prefix, wcslen(prefix));
            write(L":", 1);
        }
        writeName(element->getLocalName(), wcslen(element->getLocalName()));
        write(L">\n", 2);

    }

    _elementStack.removeLast();
    delete element;

    _prevWriteType = ELEMENT_END;
}

void
OMXMLWriterSimple::writeComment(const wchar_t* comment)
{
    TRACE("OMXMLWriterSimple::writeComment");
    PRECONDITION("Valid state", _prevWriteType == START ||
        _prevWriteType == ELEMENT_START ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END ||
        _prevWriteType == ELEMENT_END || 
        _prevWriteType == COMMENT ||
        _prevWriteType == PROC_INSTRUCTION);

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    if (_prevWriteType == ELEMENT_START || _prevWriteType == ATTRIBUTE_END)
    {
        write(L">\n", 2);
    }

    writeIndent(_level);
    write(L"<!--", 4);
    writeCommentData(comment, wcslen(comment));
    write(L"-->\n", 4);

    if (_prevWriteType != ELEMENT_END && _prevWriteType != START)
    {
        _prevWriteType = COMMENT;
    }
}

void
OMXMLWriterSimple::writeProcInstruction(const wchar_t* target, const wchar_t* instruction)
{
    TRACE("OMXMLWriterSimple::writeProcInstruction");
    PRECONDITION("Valid state", _prevWriteType == START ||
        _prevWriteType == ELEMENT_START ||
        _prevWriteType == ATTRIBUTE_START ||
        _prevWriteType == ATTRIBUTE_CONTENT ||
        _prevWriteType == ATTRIBUTE_END ||
        _prevWriteType == ELEMENT_END || 
        _prevWriteType == COMMENT ||
        _prevWriteType == PROC_INSTRUCTION);

    if (_prevWriteType == ATTRIBUTE_START || _prevWriteType == ATTRIBUTE_CONTENT)
    {
        writeAttributeEnd();
    }

    if (_prevWriteType == ELEMENT_START || _prevWriteType == ATTRIBUTE_END)
    {
        write(L">\n", 2);
    }

    writeIndent(_level);
    write(L"<?", 2);
    writeName(target, wcslen(target));
    write(L" ", 1);
    writeProcInstrData(instruction, wcslen(instruction));
    write(L"?>\n", 3);

    if (_prevWriteType != ELEMENT_END && _prevWriteType != START)
    {
        _prevWriteType = PROC_INSTRUCTION;
    }
}

void 
OMXMLWriterSimple::writeText(const wchar_t* text)
{
    TRACE("OMXMLWriterSimple::writeText");

    write(text, wcslen(text));
}

void
OMXMLWriterSimple::synchronize(void)
{
    TRACE("OMXMLWriterSimple::synchronize");

    _xmlStream->synchronize();
}

void
OMXMLWriterSimple::reset(void)
{
    TRACE("OMXMLWriterSimple::reset");

    OMVectorIterator<Element*> iter(_elementStack, OMBefore);
    while (++iter)
    {
        delete iter.value();
    }
    _elementStack.clear();
    
    _prevWriteType = NONE;
    _level = 0;

    _xmlStream->setPosition(0);
}

const wchar_t*
OMXMLWriterSimple::getPrefix(const wchar_t* ns)
{
    TRACE("OMXMLWriterSimple::getPrefix");

    if (_elementStack.count() == 0)
    {
        return g_emptyString;
    }

    Element* element = _elementStack.getAt(_elementStack.count() - 1);
    return element->getPrefix(ns);
}

const wchar_t*
OMXMLWriterSimple::getNonDefaultNSPrefix(const wchar_t* ns)
{
    TRACE("OMXMLWriterSimple::getNonDefaultNSPrefix");

    if (_elementStack.count() == 0)
    {
        return g_emptyString;
    }

    Element* element = _elementStack.getAt(_elementStack.count() - 1);
    return element->getNonDefaultNSPrefix(ns);
}


OMXMLWriterSimple::Element::Element(Element* parentElement, const wchar_t* ns, const wchar_t* localName)
: _parentElement(parentElement), _ns(ns), _localName(localName)
{
    TRACE("OMXMLWriterSimple::Element::Element");
    
    if (parentElement != 0)
    {
        OMSetIterator<OMWString, OMWString> iter(*(parentElement->getNamespaceDecls()), OMBefore);
        while (++iter)
        {
            _nspaceDecls.insert(iter.key(), iter.value());
        }
        _defaultNs = parentElement->getDefaultNamespace();
    }
    _prefix = getPrefix(ns);
}

OMXMLWriterSimple::Element::~Element()
{
    TRACE("OMXMLWriterSimple::Element::~Element");
}

bool
OMXMLWriterSimple::Element::addNamespaceDecl(const wchar_t* ns, const wchar_t* prefix)
{
    TRACE("OMXMLWriterSimple::Element::addNamespaceDecl");
    PRECONDITION("Valid namespace", ns != 0);
    PRECONDITION("Valid prefix", prefix != 0);
    
    if (wcscmp(prefix, g_internalDefaultNamespacePrefix) == 0)
    {
        _defaultNs = ns;

        if (_ns.compare(ns) == 0)
        {
            _prefix = prefix;
        }
    }
    else
    {
        if (_nspaceDecls.contains(ns))
        {
            OMWString* value;
            _nspaceDecls.find(ns, &value);
            if (value->compare(prefix) == 0)
            {
                // decl was already there so it was not added
                return false;
            }
            _nspaceDecls.remove(ns);
        }
        _nspaceDecls.insert(ns, prefix);

        if (_ns.compare(ns) == 0 && _defaultNs.compare(ns) != 0)
        {
            _prefix = prefix;
        }
    }    
    
    return true;
}

OMSet<OMWString, OMWString>* 
OMXMLWriterSimple::Element::getNamespaceDecls(void)
{
    TRACE("OMXMLWriterSimple::Element::getNamespaceDecls");
    
    return &_nspaceDecls;
}

const wchar_t*
OMXMLWriterSimple::Element::getNamespace() const
{
    TRACE("OMXMLWriterSimple::Element::getNamespace");
    
    return _ns.c_str();
}

const wchar_t*
OMXMLWriterSimple::Element::getLocalName() const
{
    TRACE("OMXMLWriterSimple::Element::getLocalName");
    
    return _localName.c_str();
}

const wchar_t* 
OMXMLWriterSimple::Element::getPrefix(const wchar_t* ns) const
{
    TRACE("OMXMLWriterSimple::Element::getPrefix");
    
    if (_defaultNs.compare(ns) == 0)
    {
        return g_internalDefaultNamespacePrefix;
    }
    else
    {
        return getNonDefaultNSPrefix(ns);
    }
}

const wchar_t* 
OMXMLWriterSimple::Element::getNonDefaultNSPrefix(const wchar_t* ns) const
{
    TRACE("OMXMLWriterSimple::Element::getNonDefaultNSPrefix");
    
    if (!_nspaceDecls.contains(ns))
    {
        return g_emptyString;
    }
    
    OMWString* prefix = 0;
    _nspaceDecls.find(ns, &prefix);
    return prefix->c_str();
}

const wchar_t*  
OMXMLWriterSimple::Element::getPrefix(void) const
{
    TRACE("OMXMLWriterSimple::Element::getPrefix");
    
    return _prefix.c_str();
}


const wchar_t* 
OMXMLWriterSimple::Element::getDefaultNamespace() const
{
    TRACE("OMXMLWriterSimple::Element::getDefaultNamespace");
    
    return _defaultNs.c_str();
}


void
OMXMLWriterSimple::writeProlog(void)
{
    TRACE("OMXMLWriterSimple::writeProlog");
    
    if (_encoding == UTF16)
    {
        OMUInt8 bom[2];
        if (_byteOrder == BE)
        {
            bom[0] = 0xFE;
            bom[1] = 0xFF;
        }
        else
        {
            bom[0] = 0xFF;
            bom[1] = 0xFE;
        }
        writeRaw(bom, 2);
    }

    write(L"<?xml version=\"1.0\" encoding=\"", 30);
    if (_encoding == UTF8)
    {
        write(L"UTF-8\"?>\n", 9);
    }
    else
    {
        write(L"UTF-16\"?>\n", 10);
    }
}

void
OMXMLWriterSimple::writeName(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeName");
    
    write(data, length);
}

void
OMXMLWriterSimple::writeElementData(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeElementData");
    
    const wchar_t* lt = L"&lt;";
    const wchar_t* gt = L"&gt;";
    const wchar_t* amp = L"&amp;";
    const wchar_t* lf = L"&#x0D;";
    
    wchar_t buffer[1024];
    unsigned int bufferPos = 0;
    const wchar_t* dataPtr = data;
    for (OMUInt32 i = 0; i<=length; i++)
    {
        if (bufferPos > 1017)
        {
            buffer[bufferPos] = L'\0';
            write(buffer, bufferPos);
            bufferPos = 0;
        }
        
        if (utf16CodeLen(dataPtr) < 0)
        {
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
        }
        else if (utf16CodeLen(dataPtr) == 1)
        {
            if (*dataPtr == L'>')
            {
                memcpy(&(buffer[bufferPos]), gt, 4 * sizeof(wchar_t));
                bufferPos += 4;
            }
            else if (*dataPtr == L'<')
            {
                memcpy(&(buffer[bufferPos]), lt, 4 * sizeof(wchar_t));
                bufferPos += 4;
            } 
            else if (*dataPtr == L'&')
            {
                memcpy(&(buffer[bufferPos]), amp, 5 * sizeof(wchar_t));
                bufferPos += 5;
            }
            else if (*dataPtr == 0x0D)
            {
                memcpy(&(buffer[bufferPos]), lf, 6 * sizeof(wchar_t));
                bufferPos += 6;
            }
            else
            {
                buffer[bufferPos] = *dataPtr;
                bufferPos++;
            }
        }
        else // code len == 2
        {
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
            dataPtr++;
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
        }
        dataPtr++;
    }
    if (bufferPos > 1)
    {
         buffer[bufferPos] = L'\0';
         write(buffer, bufferPos - 1);
    }
}

void
OMXMLWriterSimple::writeAttributeData(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeAttributeData");
    
    const wchar_t* amp = L"&amp;";
    const wchar_t* quot = L"&quot;";
    const wchar_t* apos = L"&apos;";
    const wchar_t* lf = L"&#x0D;";
    
    wchar_t buffer[1024];
    unsigned int bufferPos = 0;
    const wchar_t* dataPtr = data;
    for (OMUInt32 i = 0; i<=length; i++)
    {
        if (bufferPos > 1017)
        {
            buffer[bufferPos] = L'\0';
            write(buffer, bufferPos);
            bufferPos = 0;
        }
        
        if (utf16CodeLen(dataPtr) < 0)
        {
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
        }
        else if (utf16CodeLen(dataPtr) == 1)
        {
            if (*dataPtr == L'\"')
            {
                memcpy(&(buffer[bufferPos]), quot, 6 * sizeof(wchar_t));
                bufferPos += 6;
            }
            else if (*dataPtr == L'\'')
            {
                memcpy(&(buffer[bufferPos]), apos, 6 * sizeof(wchar_t));
                bufferPos += 6;
            }
            else if (*dataPtr == L'&')
            {
                memcpy(&(buffer[bufferPos]), amp, 5 * sizeof(wchar_t));
                bufferPos += 5;
            }
            else if (*dataPtr == 0x0D)
            {
                memcpy(&(buffer[bufferPos]), lf, 6 * sizeof(wchar_t));
                bufferPos += 6;
            }
            else
            {
                buffer[bufferPos] = *dataPtr;
                bufferPos++;
            }
        }
        else // code len == 2
        {
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
            dataPtr++;
            buffer[bufferPos] = *dataPtr;
            bufferPos++;
        }
        dataPtr++;
    }
    if (bufferPos > 1)
    {
         buffer[bufferPos] = L'\0';
         write(buffer, bufferPos - 1);
    }
}

void
OMXMLWriterSimple::writeCommentData(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeCommentData");
    
    write(data, length);
}

void
OMXMLWriterSimple::writeProcInstrData(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::writeProcInstrData");
    
    write(data, length);
}

void
OMXMLWriterSimple::writeIndent(int level)
{
    TRACE("OMXMLWriterSimple::writeIndent");
    PRECONDITION("Valid level", level >= 0);

    for (int i=0; i<level; i++)
    {
        write(L"  ", 2);
    }
}

bool
OMXMLWriterSimple::validName(const wchar_t* name)
{
    TRACE("OMXMLWriterSimple::validName");

    return (name != 0);
}

bool
OMXMLWriterSimple::validNamespace(const wchar_t* ns)
{
    TRACE("OMXMLWriterSimple::validNamespace");

    return (ns != 0);
}

bool
OMXMLWriterSimple::validPrefix(const wchar_t* prefix)
{
    TRACE("OMXMLWriterSimple::validPrefix");

    return (prefix != 0);
}

void
OMXMLWriterSimple::write(const wchar_t* data, OMUInt32 length)
{
    TRACE("OMXMLWriterSimple::write");

    if (_encoding == UTF8)
    {
        char* utf8Data = utf16ToUTF8(data);
        OMUInt32 numWritten;
        _xmlStream->write((const OMByte*)utf8Data, strlen(utf8Data), numWritten);
        delete [] utf8Data;
    }
    else
    {
        OMUInt16* buffer = new OMUInt16[length];
        
        for (OMUInt32 i = 0; i < length; i++)
        {
            buffer[i] = (OMUInt16)data[i];
            if (_swap)
            {
                OMByte* bytes = (OMByte*)&buffer[i];
                OMByte tmp = bytes[0];
                bytes[0] = bytes[1];
                bytes[1] = tmp;
            }
        }
        OMUInt32 numWritten;
        _xmlStream->write((OMByte*)buffer, length * sizeof(OMUInt16), numWritten);
        
        delete [] buffer;
    }
}

void
OMXMLWriterSimple::writeRaw(const OMByte* bytes, OMUInt32 size)
{
    TRACE("OMXMLWriterSimple::writeRaw");

    OMUInt32 numWritten;
    _xmlStream->write(bytes, size, numWritten);
}





--- NEW FILE: OMXMLWriter.h ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLWriter.h,v 1.2 2007/03/26 16:00:50 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2005, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
// Licensor of the AAF Association is British Broadcasting Corporation.
// All rights reserved.
//
//=---------------------------------------------------------------------=

#ifndef __OMXMLWRITER_H__
#define __OMXMLWRITER_H__


#include "OMDataTypes.h"
#include "OMWString.h"
#include "OMVector.h"
#include "OMSet.h"
#include "OMRawStorage.h"


#define OMXMLWRITER_DEFAULT_NAMESPACE_PREFIX  0
#define OMXMLWRITER_PARENT_ELEMENT_NAMESPACE  0


class OMXMLWriter
{
public:
    static OMXMLWriter* create(OMRawStorage* xmlStream);

    virtual ~OMXMLWriter(void) {}

    virtual void writeDocumentStart(void) = 0;
    virtual void writeDocumentEnd(void) = 0;
    virtual void writeElementStart(const wchar_t* ns, const wchar_t* localName) = 0;
    virtual void declareNamespace(const wchar_t* ns, const wchar_t* prefix) = 0;
    virtual void writeAttribute(const wchar_t* ns, const wchar_t* localName, const wchar_t* value) = 0;
    virtual void writeAttributeStart(const wchar_t* ns, const wchar_t* localName) = 0;
    virtual void writeAttributeContent(const wchar_t* value) = 0;
    virtual void writeAttributeEnd(void) = 0;
    virtual void writeElementContent(const wchar_t* content, OMUInt32 length) = 0;
    virtual void writeElementEnd(void) = 0;
    virtual void writeComment(const wchar_t* comment) = 0;
    virtual void writeProcInstruction(const wchar_t* target, const wchar_t* instruction) = 0;
    virtual void writeText(const wchar_t* text) = 0;

    virtual void synchronize(void) = 0;
    virtual void reset(void) = 0;
};



// simple implementation of the OMXMLWriter interface

// note: character escaping and formating is left up to the application for 
// writeComment and writeProcInstruction

class OMXMLWriterSimple : public OMXMLWriter
{
public:
    enum XMLUTF16ByteOrder {LE, BE};

    OMXMLWriterSimple(OMRawStorage* xmlStream);
    OMXMLWriterSimple(OMRawStorage* xmlStream, XMLUTF16ByteOrder byteOrder);
    virtual ~OMXMLWriterSimple(void);


    virtual void writeDocumentStart(void);
    virtual void writeDocumentEnd(void);
    virtual void writeElementStart(const wchar_t* ns, const wchar_t* localName);
    virtual void declareNamespace(const wchar_t* ns, const wchar_t* prefix);
    virtual void writeAttribute(const wchar_t* ns, const wchar_t* localName, const wchar_t* value);
    virtual void writeAttributeStart(const wchar_t* ns, const wchar_t* localName);
    virtual void writeAttributeContent(const wchar_t* value);
    virtual void writeAttributeEnd(void);
    virtual void writeElementContent(const wchar_t* content, OMUInt32 length);
    virtual void writeElementEnd(void);
    virtual void writeComment(const wchar_t* comment);
    virtual void writeProcInstruction(const wchar_t* target, const wchar_t* instruction);
    virtual void writeText(const wchar_t* text);

    virtual void synchronize(void);
    virtual void reset(void);

private:
    enum XMLEncoding {UTF8, UTF16};
    
    void initialise(OMRawStorage* xmlStream, XMLEncoding encoding, XMLUTF16ByteOrder byteOrder);
    
    const wchar_t* getPrefix(const wchar_t* ns);
    const wchar_t* getNonDefaultNSPrefix(const wchar_t* ns);

    class Element
    {
    public:
        Element(Element* parentElement, const wchar_t* ns, const wchar_t* localName);
        ~Element(void);

        bool addNamespaceDecl(const wchar_t* ns, const wchar_t* prefix);
        OMSet<OMWString, OMWString>* getNamespaceDecls(void);

        const wchar_t* getNamespace(void) const;
        const wchar_t* getLocalName(void) const;
        const wchar_t* getPrefix(const wchar_t* ns) const;
        const wchar_t* getNonDefaultNSPrefix(const wchar_t* ns) const;
        const wchar_t* getPrefix(void) const;
        const wchar_t* getDefaultNamespace(void) const;

    private:
        Element*            _parentElement;
        OMWString           _ns;
        OMWString           _prefix;
        OMWString           _localName;
        OMWString           _defaultNs;
        OMSet<OMWString, OMWString>   _nspaceDecls;
    };

    enum WriteType
    {
        NONE,
        START,
        END,
        ELEMENT_START,
        DELAYED_ELEMENT_START,
        ATTRIBUTE_START,
        ATTRIBUTE_CONTENT,
        ATTRIBUTE_END,
        ELEMENT_CONTENT,
        ELEMENT_END,
        COMMENT,
        PROC_INSTRUCTION
    };

    WriteType               _prevWriteType;
    OMVector<Element*>      _elementStack;
    int                     _level;


private:
    void writeProlog(void);
    void writeName(const wchar_t* data, OMUInt32 length);
    void writeElementData(const wchar_t* data, OMUInt32 length);
    void writeAttributeData(const wchar_t* data, OMUInt32 length);
    void writeCommentData(const wchar_t* data, OMUInt32 length);
    void writeProcInstrData(const wchar_t* data, OMUInt32 length);
    void writeIndent(int level);

    bool validName(const wchar_t* name);
    bool validNamespace(const wchar_t* ns);
    bool validPrefix(const wchar_t* prefix);

    void write(const wchar_t* data, OMUInt32 length);
    void writeRaw(const OMByte* bytes, OMUInt32 size);

private:
    OMRawStorage*       _xmlStream;
    XMLEncoding         _encoding;
    XMLUTF16ByteOrder   _byteOrder;
    bool                _swap;
};


#endif

--- NEW FILE: OMXMLUtilities.cpp ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLUtilities.cpp,v 1.2 2007/03/26 16:00:51 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2005, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
[...2052 lines suppressed...]
        // prepare the file scheme URL (+1 for '/', +1 for '\0')
        char *mb_uri = new char[strlen(escaped) + strlen("file://") +1 +1];
        strcpy(mb_uri, "file://");
        if (*escaped != '/')		// ensure a leading path slash is present
            strcat(mb_uri, "/");
        strcat(mb_uri, escaped);
    
        u8stowcs(uri, mb_uri, strlen(mb_uri)+1);		// convert back to wcs
        delete [] mb_uri;
    }

    delete [] escaped;
    delete [] tmp;
}


/**************** End of copied functions ************************/




--- NEW FILE: OMWString.h ---
//=---------------------------------------------------------------------=
//
// $Id: OMWString.h,v 1.2 2007/03/26 16:00:53 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2005, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
// Licensor of the AAF Association is British Broadcasting Corporation.
// All rights reserved.
//
//=---------------------------------------------------------------------=

#ifndef __OMWSTRING_H__
#define __OMWSTRING_H__

#include "wchar.h"

class OMWString
{
public:
    OMWString();
    OMWString(const OMWString& ws);
    OMWString(const wchar_t* ws);

    ~OMWString();

    int compare(const OMWString& rhs) const;
    int compare(const wchar_t* rhs) const;
    size_t length() const;
    const wchar_t* c_str() const;
    
    OMWString& operator=(const OMWString& rhs);
    OMWString& operator=(const wchar_t* rhs);

    bool operator==(const OMWString& rhs) const;
    bool operator==(const wchar_t* rhs) const;
    bool operator!=(const OMWString& rhs) const;
    bool operator!=(const wchar_t* rhs) const;
    bool operator<(const OMWString& rhs) const;
    bool operator<(const wchar_t* rhs) const;

private:
    wchar_t* _ws;
};

#endif //__OMWSTRING_H__


Index: OMPropertyDefinition.cpp
===================================================================
RCS file: /cvsroot/aaf/AAF/ref-impl/src/OM/OMPropertyDefinition.cpp,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** OMPropertyDefinition.cpp	6 Feb 2007 15:46:14 -0000	1.10
--- OMPropertyDefinition.cpp	26 Mar 2007 16:00:55 -0000	1.11
***************
*** 129,130 ****
--- 129,137 ----
    return true;
  }
+ 
+ bool OMBuiltinPropertyDefinition::isUniqueIdentifier(void) const
+ {
+   TRACE("OMBuiltinPropertyDefinition::isUniqueIdentifier");
+   ASSERT("Unimplemented code not reached", false);
+   return true;
+ }

--- NEW FILE: OMXMLStorage.cpp ---
//=---------------------------------------------------------------------=
//
// $Id: OMXMLStorage.cpp,v 1.2 2007/03/26 16:00:52 philipn Exp $
//
// The contents of this file are subject to the AAF SDK Public
// Source License Agreement (the "License"); You may not use this file
// except in compliance with the License.  The License is available in
// AAFSDKPSL.TXT, or you may obtain a copy of the License from the AAF
// Association or its successor.
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See
// the License for the specific language governing rights and limitations
// under the License.
//
// The Original Code of this file is Copyright 1998-2004, Licensor of the
// AAF Association.
//
// The Initial Developer of the Original Code of this file and the
[...985 li...
 
[truncated message content]