OU/CWE-ou-minkata
2
3
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-14 02:27:40 -04:00
Code Releases Activity

Initial Commit of CyanWorlds.com Engine Open Source Client/Plugin

Browse Source
This commit is contained in:
JWPlatt
2011-03-12 12:34:52 -05:00
commit a20a222fc2
3976 changed files with 1301356 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

161
MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/NucleusLib/pnKeyedObject/plKeyImp.h Normal file
View File

@ -0,0 +1,161 @@
/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#ifndef plKeyImp_inc
#define plKeyImp_inc
#include "plKey.h"
#include "hsTemplates.h"
#include "plUoid.h"
#include "hsBitVector.h"
#include "plRefFlags.h"
//------------------------------------
// plKey is a handle to a keyedObject
//------------------------------------
class plKeyImp : public plKeyData
{
public:
plKeyImp();
plKeyImp(plUoid, UInt32 pos,UInt32 len);
virtual ~plKeyImp();
virtual const plUoid& GetUoid() const { return fUoid; }
virtual const char* GetName() const;
virtual hsKeyedObject* GetObjectPtr();
virtual hsKeyedObject* ObjectIsLoaded() const;
virtual hsKeyedObject* VerifyLoaded();
// called before writing to disk so that static keys can have faster lookups (int compare instead of string compare)
void SetObjectID(UInt32 id) {fUoid.SetObjectID(id);}
//----------------------
// I/O
// ResMgr performs read, so it can search for an existing instance....
//----------------------
void Read(hsStream* s);
void Write(hsStream* s);
void WriteObject(hsStream* s);
// For when you need to skip over a key in a stream
static void SkipRead(hsStream* s);
UInt32 GetStartPos() const { return fStartPos; } // for ResMgr to read the Objects
UInt32 GetDataLen() const { return fDataLen; } // for ResMgr to read the Objects
//----------------------
// Allow a keyed object to behave as if it has an active ref when in fact the object
// should only be active ref'ed by a non-keyed parent. Essentially just bumps/decs
// the active ref count to facilitate normal object creation/destruction
//----------------------
virtual hsKeyedObject* RefObject(plRefFlags::Type flags = plRefFlags::kActiveRef);
virtual void UnRefObject(plRefFlags::Type flags = plRefFlags::kActiveRef);
//----------------------
// Release has two behaviors, depending on whether the ref is active or passive:
// Active - Release decs the ActiveRefCnt. When it gets to zero, the object will be deleted.
// Passive - Unregisters my interest in when the object is created or destroyed.
//----------------------
virtual void Release(plKey targetKey);
void UnRegister();
void SetUoid(const plUoid& uoid);
void SetupNotify(plRefMsg* msg, plRefFlags::Type flags);
// hsKeyedObject use only!
hsKeyedObject* SetObjectPtr(hsKeyedObject* p);
////////////////////////////////////////////////////////////////////////////
// ResManager/Registry use only!
//
//----------------------
// Clone access
//----------------------
void AddClone(plKeyImp* c);
void RemoveClone(plKeyImp* c) const;
plKey GetClone(UInt32 playerID, UInt32 cloneID) const;
void CopyForClone(const plKeyImp* p, UInt32 playerID, UInt32 cloneID); // Copy the contents of p for cloning process
UInt32 GetNumClones();
plKey GetCloneByIdx(UInt32 idx);
plKey GetCloneOwner() { return fCloneOwner; }
void NotifyCreated();
void ISetupNotify(plRefMsg* msg, plRefFlags::Type flags); // Setup notifcations for reference, don't send anything.
void AddRef(plKeyImp* key) const;
UInt16 GetNumRefs() const { return fRefs.GetCount(); }
plKeyImp* GetRef(int i) const { return fRefs[i]; }
void RemoveRef(plKeyImp *key) const;
virtual UInt16 GetActiveRefs() const { return fNumActiveRefs; }
virtual UInt16 GetNumNotifyCreated() const { return fNotifyCreated.GetCount(); }
virtual plRefMsg* GetNotifyCreated(int i) const { return fNotifyCreated[i]; }
virtual const hsBitVector& GetActiveBits() const { return fActiveRefs; }
protected:
void AddNotifyCreated(plRefMsg* msg, plRefFlags::Type flags);
void ClearNotifyCreated();
UInt16 GetNumNotifyCreated() { return fNotifyCreated.GetCount(); }
plRefMsg* GetNotifyCreated(int i) { return fNotifyCreated[i]; }
void RemoveNotifyCreated(int i);
UInt16 IncActiveRefs() { return ++fNumActiveRefs; }
UInt16 DecActiveRefs() { return fNumActiveRefs ? --fNumActiveRefs : 0; }
hsBool IsActiveRef(int i) const { return fActiveRefs.IsBitSet(i) != 0; }
void SetActiveRef(int i, hsBool on=true) { fActiveRefs.SetBit(i, on); }
hsBool IsNotified(int i) const { return fNotified.IsBitSet(i) != 0; }
void SetNotified(int i, hsBool on=true) { fNotified.SetBit(i, on); }
void SatisfyPending(plRefMsg* msg) const;
void SatisfyPending() const;
void INotifySelf(hsKeyedObject* ko);
void INotifyDestroyed();
void IClearRefs();
void IRelease(plKeyImp* keyImp);
hsKeyedObject* fObjectPtr;
// These fields are the ones actually saved to disk
plUoid fUoid;
UInt32 fStartPos; // where I live in the Datafile
UInt32 fDataLen; // Length in the Datafile
// Following used by hsResMgr to notify on defered load or when a passive ref is destroyed.
UInt16 fNumActiveRefs; // num active refs on me
hsBitVector fActiveRefs; // Which of notify created are active refs
hsBitVector fNotified; // which of notifycreated i've already notified.
hsTArray<plRefMsg*> fNotifyCreated; // people to notify when I'm created or destroyed
mutable hsTArray<plKeyImp*> fRefs; // refs I've made (to be released when I'm unregistered).
mutable Int16 fPendingRefs; // Outstanding requests I have out.
mutable hsTArray<plKeyImp*> fClones; // clones of me
mutable plKey fCloneOwner; // pointer for clones back to the owning key
};
#endif // hsRegistry_inc