CM2MMessageListener.h

//========================================================================================
// 
// $File$
// 
// Owner: dwaterfa
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// ADOBE CONFIDENTIAL
// 
// 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 __CM2MMessageListener__
#define __CM2MMessageListener__

#include "IM2MMessageListener.h"
#include "IClassInfo.h"
#include "IObjectModel.h"
#include "IPMStream.h"



class CM2MMessageListener : public CPMUnknown<IM2MMessageListener>
{
public:
 class myPrivateData : public PrivateData
 {
 static const int32 kPreCheckValue = 101363;
 static const int32 kPostCheckValue = 101364;

 public:
 virtual void Message(IM2MMessageListener::MessageHelper& helper) = 0;

 virtual void SubListenerSnapshotReadWrite(IPMStream* stream) = 0;

 virtual void SnapshotReadWrite(IPMStream* stream)
 {
 // This helps catch override errors. See SnapshotRead() below.
 int32 pre_checkValue = kPreCheckValue;
 stream->XferInt32(pre_checkValue);

 ASSERT_MSG((stream->IsWriting()) ||
 (pre_checkValue == kPreCheckValue), "CM2MMessageListener::SnapshotReadWrite() - a sub-listener has overriden CM2MMessageListener::myPrivateData::SnapshotReadWrite(). Implement only CM2MMessageListener::myPrivateData::SubListenerSnapshotReadWrite()");

 // Write out the index of the SubListener who created the data.
 stream->XferInt32(fSubListenerIndex);
 ASSERT(fSubListenerIndex >= 0);

 //
 // Let the SubListener snapshot. If they don't have any data
 // that ever changes between construction and the call to
 // Validate() then they don't have to do anything.
 //
 SubListenerSnapshotReadWrite(stream);

 // This helps catch unfinished read errors. See
 // SnapshotRead() below.
 int32 post_checkValue = kPostCheckValue;
 stream->XferInt32(post_checkValue);

 ASSERT_MSG((stream->IsWriting()) ||
 (post_checkValue == kPostCheckValue), "CM2MMessageListener::SnapshotReadWrite() - a sub-listener has a sub-listener has not read all that it had previously written");

 }

 virtual void Abandon(bool16)
 { }

 void SetSubListenerIndex(int32 n)
 { fSubListenerIndex = n; }

 private:
 int32 fSubListenerIndex;

 };

protected:
 virtual int32 GetSubListenerCount() const = 0;

 typedef bool16 (*funcGetCanHandle)(const IClassInfo* cInfo);

 virtual funcGetCanHandle GetNthSubListenerGetCanHandle(int32 n) const = 0;

 typedef void (*funcGetMessages)(const PMIID*& targetM, uint32& targetMSize,
 const PMIID*& ancestorM, uint32& ancestorMSize,
 const PMIID*& descendentM, uint32& descendentMSize,
 const PMIID*& unrelatedM, uint32& unrelatedMSize);

 virtual funcGetMessages GetNthSubListenerGetMessages(int32 n) const = 0;

 typedef myPrivateData* (*funcCreateFor)(IM2MMessageListener::MessageHelper& helper) ;

 virtual funcCreateFor GetNthSubListenerCreateFor(int32 n) const = 0;

 typedef myPrivateData* (*funcSnapshotRead)(const UIDRef& targetRef,
 IPMStream* inStream);

 virtual funcSnapshotRead GetNthSubListenerSnapshotRead(int32 n) const = 0;

 CM2MMessageListener(IPMUnknown* boss);

 virtual void GetMessagesFor(const IClassInfo* cInfo,
 const PMIID*& targetM,
 uint32& targetMSize,
 const PMIID*& ancestorM,
 uint32& ancestorMSize,
 const PMIID*& descendentM,
 uint32& descendentMSize,
 const PMIID*& unrelatedM,
 uint32& unrelatedMSize) const
 {
 ASSERT((targetM == nil) && (targetMSize == 0));
 ASSERT((ancestorM == nil) && (ancestorMSize == 0));
 ASSERT((descendentM == nil) && (descendentMSize == 0));
 ASSERT((unrelatedM == nil) && (unrelatedMSize == 0));

 const int32 slCount = GetSubListenerCount();

 for (int32 n = 0; n < slCount; n++)
 {
 //
 // If GetCanHandle() function returns a match then we get the
 // messages from the SubListener. First match wins.
 //
 if ((*GetNthSubListenerGetCanHandle(n))(cInfo))
 {
 (*GetNthSubListenerGetMessages(n))(targetM, targetMSize,
 ancestorM, ancestorMSize,
 descendentM, descendentMSize,
 unrelatedM, unrelatedMSize);
 break;
 }
 }
 }

 virtual void Message(MessageHelper& helper, PrivateData* data)
 {
 myPrivateData* myData = (myPrivateData*)data;

 if (myData == nil)
 {
 //
 // No private data defined. Try to create some. Extract an
 // IClassInfo from the helper.
 //
 InterfacePtr<const IControllingUnknown> cu(helper.GetTarget(), UseDefaultIID());
 InterfacePtr<const IObjectModel> om(GetExecutionContextSession(), UseDefaultIID());
 InterfacePtr<const IClassInfo> cInfo(om->QueryClassInfo(cu->GetClass()));
 const int32 slCount = GetSubListenerCount();

 for (int32 n = 0; n < slCount; n++)
 {
 //
 // If there is only one sub-listener, or the GetCanHandle()
 // function returns a match then we let the SubListener create
 // some private data. First match wins.
 //
 if ((slCount == 1) ||
 ((*GetNthSubListenerGetCanHandle(n))(cInfo)))
 {
 //
 // This SubListener get a chance to create. If it fails to
 // do so we purposely DO NOT let another SubListener try.
 //
 // Because your Listener will ONLY be called with messages
 // that it intested in the only reason to not create the
 // private data might be some state of the object - but
 // this is rare case.
 // 
 myData = (*GetNthSubListenerCreateFor(n))(helper);
 if (myData)
 {
 myData->SetSubListenerIndex(n);
 helper.AddPrivateData(myData);
 }
 break;
 }
 }
 
 }

 if (myData)
 {
 myData->Message(helper);
 }
 }

 virtual PrivateData* SnapshotRead(const UIDRef& targetRef,
 IPMStream* inStream)
 {
 int32 pre_checkValue, post_checkValue, n;

 // Did someone override SnapshotWrite() but not this? Hard to check
 // the reverse case.
 inStream->XferInt32(pre_checkValue);
 ASSERT_MSG((pre_checkValue == 101363), "CM2MMessageListener::SnapshotRead() - a sub-listener has overriden CM2MMessageListener::myPrivateData::SnapshotReadWrite(). Implement only CM2MMessageListener::myPrivateData::SubListenerSnapshotReadWrite()");

 // Get the SubListener index.
 inStream->XferInt32(n);
 ASSERT((n >= 0) && (n < GetSubListenerCount()));

 // Call the SubListener's SnapshotRead() method.
 myPrivateData* myData = (*GetNthSubListenerSnapshotRead(n))(targetRef, inStream);
 myData->SetSubListenerIndex(n);

 // Make sure everything which was expected to be
 // read was read.
 inStream->XferInt32(post_checkValue);
 ASSERT_MSG((post_checkValue == 101364), "CM2MMessageListener::SnapshotRead() - a sub-listener has not read all that it had previously written");

 return myData;
 }


};


#endif // __CM2MMessageListener__