IMemoryManager.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.
// 
//========================================================================================

#include "PMTypes.h"
#include "IPMUnknown.h"

#ifndef __IMemoryManager__
#define __IMemoryManager__

typedef void (*MemoryNotificationFunction)(int32 level, void *refPtr);

typedef void (*NewMemoryNotificationFunction)(int32 level, void *refPtr, bool16 bInGrowZone);

typedef void (*AdviseMemoryStateNotificationFunction)(int32 state, void *refPtr);

class IMemoryManager : public IPMUnknown
{
 public:
 enum { kDefaultIID = IID_IMEMORYMANAGER };
 
 virtual void Init() = 0;
 
 typedef enum
 {
 kNoPurge = -1,
 kSwitchingDocuments = 0, // release document oriented caches
 kSwitchingApplications = 1, // release temporary memory
 kLowMemory1 = 2,
 kLowMemory2 = 3,
 kLowMemory3 = 4,
 kReleaseEverything = 5, // release all you can
 kMaxMemoryLevel = 5 
 } PurgeLevel;
 
 typedef enum
 {
 kNormalMemoryState = 0, // Normal state, there is plenty of memory
 kConstrainedMemoryState = 1, // Heap is relatively full, around 10-20% free (a good time to fix sizes of caches)
 kLowMemoryState = 2 // Heap is very full, less than 5% free (a good time to reduce memory footprint)
 } MemoryState;
 
 virtual void PurgeObjects(PurgeLevel purgeLevel) = 0;
 
 virtual void CheckMemoryState() = 0;

 virtual bool16 MemoryPanic() = 0;

 virtual bool16 CheckMemory(bool16 showAlerts = kFalse) = 0; 
 
 virtual bool16 MemoryIsLow() = 0;
 
 virtual bool16 MemoryIsFailing() = 0;
 


 // NOTE that the two versions of these functions are named differently (as opposed to overloaded)
 // *Don't* overload them, or code which calls these functions then fails to compile
 // as the compiler cannot disambiguate the caller's first parameter which could either be
 // a pointer to a virtual function or a static function in the caller's class

 virtual void RegisterMemoryNotification(MemoryNotificationFunction func, void *refPtr) = 0;
 
 virtual void RegisterNewMemoryNotification(NewMemoryNotificationFunction func, void *refPtr, bool16 bGrowZoneFailSafe) = 0;

 virtual void UnregisterMemoryNotification(MemoryNotificationFunction func, void *refPtr) = 0;

 virtual void UnregisterNewMemoryNotification(NewMemoryNotificationFunction func, void *refPtr) = 0;
 
 virtual void RegisterAdviseMemoryStateNotification(AdviseMemoryStateNotificationFunction func, void *refPtr) = 0;

 virtual void UnregisterAdviseMemoryStateNotification(AdviseMemoryStateNotificationFunction func, void *refPtr) = 0;

 virtual uint32 GetPurgeCount() const = 0;

 virtual uint32 GetPurgeTime() const = 0;


 virtual bool16 PurgeInProgress() const = 0;

 virtual bool16 HandleAllocationFailure(size_t blockSize) = 0;

 virtual void ResetFailureHandler() = 0;
};


#endif // __IMemoryManager__