UIDRef.h

//========================================================================================
// 
// $File$
// 
// Owner: ?
// 
// $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 __UIDREF__
#define __UIDREF__

#include "IPMUnknown.h"

class IDataBase; 

class UIDRef
{
 public:
 typedef base_type data_type;
 
 /* UIDRef's constructed without parameters are invalid. They can be used, but
 attempts to instantiate them will fail.
 */
 UIDRef() :
 fDB(nil), fUID(kInvalidUID)
 {}

 UIDRef(IDataBase *db, UID id) :
 fDB(db), fUID(id) 
 {}

 IDataBase *GetDataBase() const
 { return fDB; }
 
 UID GetUID() const
 { return fUID; }
 
 void ResetUID(UID newUID)
 { fUID = newUID; }
 
// Don't remove these next two. Even though we are just POD (plain old data) and
// seem unnecessary (and slow). Otherwise Metrowerks will generate horrendous code 
// for the operator! and operator void* below. Yuck.
 bool16 operator==(const UIDRef& other) const
 { //An open question here--there are 3 ways to have an invalid UIDRef. Should any invalid UIDRef compare equal to any other?
 //Assert for now that we only use "doubly-invalid" invalid UIDRefs when comparing and see what shows up.

 //ASSERT( fDB || fUID == kInvalidUID);
 //ASSERT( other.fDB || other.fUID == kInvalidUID);
// ASSERT( fDB == other.fDB || fUID != kInvalidUID || other.fUID != kInvalidUID);

// ASSERT( fDB == nil && fUID == kInvalidUID || fDB != nil && fUID != kInvalidUID);
// ASSERT( other.fDB == nil && other.fUID == kInvalidUID || other.fDB != nil && other.fUID != kInvalidUID);
 return fUID == other.fUID && fDB == other.fDB;
 }
 bool16 operator!=(const UIDRef& other) const
 { return !(*this == other); }


 bool16 operator<(const UIDRef& other) const
 { return fDB == other.fDB ? fUID < other.fUID : fDB < other.fDB; }

// The next two functions allow testing of UIDRefs in conditionals, e.g. :
//
// UIDRef myUIDRef(aDB, aUID);
// ...
// if(!myUIDRef) {
// myUIDRef = giveMeAnotherUIDRef();
// }
// ASSERT_MSG(myUIDRef, "nil");
// 

 bool16 operator!() const; // true if bad
 operator void*() const; // nonzero if good

 
 bool16 ExistsInDB() const;

 IPMUnknown* Instantiate( PMIID iid ) const ;

public: 

// For convenience we provide a null UIDRef. E.g.:
// UIDRef myUID(UIDRef::gNull);

 static const UIDRef gNull;

// Debugger cannot handle long symbol names
// disable warning again
#ifdef WIN32

#endif // WIN32

private:
 IDataBase *fDB;
 UID fUID;
};

extern const UIDRef kInvalidUIDRef;

inline bool16 UIDRef::operator!() const
{ 
 //return *this == UIDRef::gNull; 
 return fDB == nil || fUID == kInvalidUID;
}

inline UIDRef::operator void*() const
{ 
 // Is there a cleaner way to do this?
 //return *this == UIDRef::gNull ? nil : const_cast<UIDRef*>(this);
 
 // Require both members to be valid:
 return (fDB == nil || fUID == kInvalidUID) ? nil : const_cast<UIDRef*>(this);
}

inline bool16 UIDRef::ExistsInDB() const
{
 if (!(*this)) // use operator! for validity test
 return kFalse;
 else
 return (fDB->GetClass(fUID) != kInvalidClass ? kTrue : kFalse);
}

inline IPMUnknown* UIDRef::Instantiate( PMIID iid ) const
{
 return ( fDB ? fDB->Instantiate( fUID, iid ) : nil ) ;
}

#endif // __UIDREF__