XMLReference.h

//========================================================================================
// 
// $File$
// 
// Owner: robin briggs
// 
// $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 __XMLReference__
#define __XMLReference__

typedef SBOSID LSID;
const LSID kInvalidLSID = kInvalidSBOSID;

class IIDXMLElement;
class IPMStream;

class XMLReference {
public:
 typedef base_type data_type;


 XMLReference() :
 fBaseUIDRef(), fSubItem(kInvalidLSID)
 {}


 XMLReference(const UIDRef& baseUIDRef, LSID subItemID = kInvalidLSID) :
 fBaseUIDRef(baseUIDRef), fSubItem(subItemID)
 {}


 XMLReference(const XMLReference& other) :
 fBaseUIDRef(other.fBaseUIDRef), fSubItem(other.fSubItem)
 {}


 const UIDRef& GetUIDRef() const
 { return fBaseUIDRef; }


 UID GetUID() const
 { return fBaseUIDRef.GetUID(); }


 IDataBase *GetDataBase() const
 { return fBaseUIDRef.GetDataBase(); }


 LSID GetLogicalID() const
 { return fSubItem; }


 void SetLogicalID(LSID newValue)
 { fSubItem = newValue; }


 IIDXMLElement* Instantiate(void) const;


 void ReadWrite(IPMStream *s, IDataBase *db = nil);
 

 bool16 operator == (const XMLReference& other) const
 { return fBaseUIDRef == other.fBaseUIDRef && fSubItem == other.fSubItem; } 


 inline bool16 operator != (const XMLReference& compareAgainst) const
 { return (!(*this == compareAgainst)); }

 inline XMLReference& operator = (const XMLReference& other)
 { fBaseUIDRef = other.fBaseUIDRef; fSubItem = other.fSubItem; return *this;}

 bool16 operator < (const XMLReference& compareAgainst) const;

private:
 UIDRef fBaseUIDRef;
 LSID fSubItem;
 };

DECLARE_BASE_TYPE(XMLReference); // no special copy

const XMLReference kInvalidXMLReference;

#if 0
class XMLReferenceWrapper
{
 public:
 XMLReferenceWrapper(XMLReference element) : fElement(element) { }
 bool16 operator<(const XMLReferenceWrapper& other) const
 { return ((fElement.GetDataBase() <= other.fElement.GetDataBase()) &&
 (fElement.GetUID() <= other.fElement.GetUID()) &&
 (fElement.GetLogicalID() < other.fElement.GetLogicalID())); }
 
 private:
 XMLReference fElement;
};

DECLARE_BASE_TYPE(XMLReferenceWrapper); // no special copy
#endif

#endif // __XMLReference__