IRIDX.h

//========================================================================================
// 
// $File$
// 
// Owner: Paul Messmer
// 
// $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 __IRIDX__
#define __IRIDX__

#include "ShuksanID.h"
#include "IDataBase.h"

#include <utility>
#include <vector>

//========================================================================================

class RIDXSource
{
private:

 UID fUID;
 ImplementationID fImplID;

public:

 RIDXSource ()
 {}

 RIDXSource (UID sourceUID, ImplementationID sourceImplID) :
 fUID (sourceUID),
 fImplID (sourceImplID)
 {}

 RIDXSource (uint32 sourceUID, uint32 sourceImplID) :
 fUID (UID (sourceUID)),
 fImplID (ImplementationID (sourceImplID))
 {}

 UID GetUID () const { return fUID; }

 ImplementationID GetImplID () const { return fImplID; }
};

//========================================================================================

inline bool operator == (const RIDXSource &lhs, const RIDXSource &rhs)
{
 return lhs.GetUID () == rhs.GetUID () &&
 lhs.GetImplID () == rhs.GetImplID ();
}

inline bool operator != (const RIDXSource &lhs, const RIDXSource &rhs)
{
 return lhs.GetUID () != rhs.GetUID () ||
 lhs.GetImplID () != rhs.GetImplID ();
}

inline bool operator < (const RIDXSource &lhs, const RIDXSource &rhs)
{
 if (lhs.GetUID () > rhs.GetUID ()) return false;
 if (lhs.GetUID () < rhs.GetUID ()) return true;
 return lhs.GetImplID () < rhs.GetImplID ();
}

//========================================================================================

class RIDXTarget
{
public:

 enum Type
 {
 kUIDAsReference = 0, 

 kUIDAsObject = 1
 };

private:

 uint32 fType;
 uint32 fValue;

public:

 RIDXTarget () :
 fType(0),
 fValue(0)
 {}

 RIDXTarget (Type targetType, uint32 targetValue) :
 fType ((uint32) targetType),
 fValue (targetValue)
 {}

 RIDXTarget (uint32 targetType, uint32 targetValue) :
 fType (targetType),
 fValue (targetValue)
 {}

 RIDXTarget::Type GetType () const { return RIDXTarget::Type (fType); }

 uint32 GetValue () const { return fValue; }
};

//========================================================================================

inline bool operator == (const RIDXTarget &lhs, const RIDXTarget &rhs)
{
 return lhs.GetType () == rhs.GetType () &&
 lhs.GetValue () == rhs.GetValue ();
}

inline bool operator != (const RIDXTarget &lhs, const RIDXTarget &rhs)
{
 return lhs.GetType () != rhs.GetType () ||
 lhs.GetValue () != rhs.GetValue ();
}

inline bool operator < (const RIDXTarget &lhs, const RIDXTarget &rhs)
{
 if ((uint32) lhs.GetType () > (uint32) rhs.GetType ()) return false;
 if ((uint32) lhs.GetType () < (uint32) rhs.GetType ()) return true;
 return lhs.GetValue () < rhs.GetValue ();
}

//========================================================================================

class RIDXReference
{
 RIDXSource fSource;
 RIDXTarget fTarget;

public:

 RIDXReference ()
 {}

 RIDXReference (RIDXSource source, RIDXTarget target) :
 fSource (source),
 fTarget (target)
 {}

 RIDXReference (UID sourceUID, ImplementationID sourceImplID, RIDXTarget::Type targetType, uint32 targetValue) :
 fSource (RIDXSource (sourceUID, sourceImplID)),
 fTarget (RIDXTarget (targetType, targetValue))
 {}

 RIDXReference (uint32 sourceUID, uint32 sourceImplID, uint32 targetType, uint32 targetValue) :
 fSource (RIDXSource (sourceUID, sourceImplID)),
 fTarget (RIDXTarget (targetType, targetValue))
 {}
 
 RIDXSource GetSource () const { return fSource; }

 RIDXTarget GetTarget () const { return fTarget; }
};

//========================================================================================

inline bool operator == (const RIDXReference &lhs, const RIDXReference &rhs)
{
 return lhs.GetSource ().GetUID () == rhs.GetSource ().GetUID () &&
 lhs.GetSource ().GetImplID () == rhs.GetSource ().GetImplID () &&
 lhs.GetTarget ().GetType () == rhs.GetTarget ().GetType () &&
 lhs.GetTarget ().GetValue () == rhs.GetTarget ().GetValue ();
}

inline bool operator != (const RIDXReference &lhs, const RIDXReference &rhs)
{
 return lhs.GetSource ().GetUID () != rhs.GetSource ().GetUID () ||
 lhs.GetSource ().GetImplID () != rhs.GetSource ().GetImplID () ||
 lhs.GetTarget ().GetType () != rhs.GetTarget ().GetType () ||
 lhs.GetTarget ().GetValue () != rhs.GetTarget ().GetValue ();
}

inline bool operator < (const RIDXReference &lhs, const RIDXReference &rhs)
{
 if (lhs.GetSource ().GetUID () > rhs.GetSource ().GetUID ()) return false;
 if (lhs.GetSource ().GetUID () < rhs.GetSource ().GetUID ()) return true;
 if (lhs.GetSource ().GetImplID () > rhs.GetSource ().GetImplID ()) return false;
 if (lhs.GetSource ().GetImplID () < rhs.GetSource ().GetImplID ()) return true;
 if ((uint32) lhs.GetTarget ().GetType () > (uint32) rhs.GetTarget ().GetType ()) return false;
 if ((uint32) lhs.GetTarget ().GetType () < (uint32) rhs.GetTarget ().GetType ()) return true;
 return lhs.GetTarget ().GetValue () < rhs.GetTarget ().GetValue ();
}

//========================================================================================

class IRIDXQuery;

class IRIDX;

//========================================================================================

class IRIDXAccess : public IPMUnknown
{
public:
 enum { kDefaultIID = IID_IRIDXACCESS };
 
 virtual IRIDX *QueryRIDX() = 0;
 
 virtual UIDRef GetRIDX() = 0;
};

//========================================================================================

namespace RIDXAccess
{
 inline IRIDX *QueryRIDX (IDataBase *db)
 {
 InterfacePtr<IRIDXAccess> ridxAccess (db, db->GetRootUID(), UseDefaultIID());
 return ridxAccess ? ridxAccess->QueryRIDX () : 0;
 }
}

//========================================================================================

class IRIDX : public IPMUnknown
{
public:

 enum { kDefaultIID = IID_IRIDX };

 typedef std::vector<RIDXTarget> Targets; // These typedefs are not Doc++ commented
 typedef std::vector<RIDXSource> Sources; // because they are not used in the current
 typedef std::vector<RIDXReference> References; // set of public APIs.

 virtual void Initialize () = 0;

 virtual void ProcessScheduledIndexing () = 0;

 enum QueryType
 {
 kDynamicQuery = 0,

 kLockedQuery = 1
 };

 enum CoherencyType
 {
 kCoherentAtOutermostQueryCreation = 0,

 kCoherentAtThisQueryCreation = 1
 };

 virtual IRIDXQuery *CreateQuery (QueryType queryType, CoherencyType coherencyType) const = 0;

 virtual bool HasOutstandingQuery () const = 0;

 virtual bool HasOutstandingLockedQuery () const = 0;

 virtual void WontProcessScheduledIndexing () = 0;

 virtual bool UpdateInProgress () const = 0;
};

//========================================================================================

class IRIDXQuery : public IPMUnknown
{
public:
 enum { kDefaultIID = IID_IRIDXQUERY };

 virtual IDataBase *GetDataBase () = 0;

 virtual void StartTarget (RIDXTarget target) = 0;

 virtual bool GetNextSource (RIDXSource &source) = 0;
};

//========================================================================================

#endif // __IRIDX__