OU
/
CWE-ou-minkata
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git
2
1
Fork 0
Code Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
577 Commits
79 Branches
23 Tags
171 MiB
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
CWE-ou-minkata/Sources/Plasma/PubUtilLib/plVault/plVaultNode.h

1029 lines
32 KiB
Raw Permalink Blame History

/*==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/>.
Additional permissions under GNU GPL version 3 section 7
If you modify this Program, or any covered work, by linking or
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK,
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK
(or a modified version of those libraries),
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA,
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the
licensors of this Program grant you additional
permission to convey the resulting work. Corresponding Source for a
non-source form of such a combination shall include the source code for
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered
work.
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==*/
#if 0
#ifndef plVaultNode_h_inc
#define plVaultNode_h_inc
#include "hsTypes.h"
#include "hsBitVector.h"
#include "../plUnifiedTime/plUnifiedTime.h"
#include "../plNetCommon/plNetServerSessionInfo.h"
#include "../plNetCommon/plSpawnPointInfo.h"
#include "../plNetCommon/plNetCommon.h"
#include "../plUUID/plUUID.h"
#include "plVault.h"
#include "plVaultNodeIterator.h"
#include <string>
#include <vector>
////////////////////////////////////////////////////////////////////
class plVaultNode;
class plVaultFolderNode;
class plVaultImageNode;
class plVaultTextNoteNode;
class plVaultSDLNode;
class plVaultAgeLinkNode;
class plVaultChronicleNode;
class plVaultMgrNode;
class plVaultPlayerNode;
class plVaultPlayerInfoNode;
class plVaultPlayerInfoListNode;
class plVaultAgeNode;
class plVaultAgeInfoNode;
class plVaultAgeInfoListNode;
class plVaultSystemNode;
class plStateDataRecord;
class plURL;
struct hsPoint3;
////////////////////////////////////////////////////////////////////
typedef bool (*plNodeCompareProc)( const plVaultNode * A, const plVaultNode * B );
class plVaultNode
{
public:
struct MatchesNode
{
const plVaultNode * fNode;
MatchesNode( const plVaultNode * node ): fNode( node ) {}
bool operator()( const plVaultNode * node ) const;
};
friend struct MatchesNode;
void SetID( UInt32 v );
void SetType( UInt8 v );
void SetPermissions( UInt32 v );
void SetOwnerNodeID( UInt32 v );
void SetGroupNodeID( UInt32 v );
void SetCreatorNodeID( UInt32 v );
void SetCreateTime( const plUnifiedTime * v );
void SetCreateTime( const plUnifiedTime & v );
void SetCreateAgeTime( const plUnifiedTime * v );
void SetCreateAgeTime( const plUnifiedTime & v );
void SetCreateAgeName( const char * v );
void SetCreateAgeGuid( const plUUID * v );
void SetCreateAgeGuid( const plUUID & v );
void SetInt32_1( Int32 v );
void SetInt32_2( Int32 v );
void SetInt32_3( Int32 v );
void SetInt32_4( Int32 v );
void SetUInt32_1( UInt32 v );
void SetUInt32_2( UInt32 v );
void SetUInt32_3( UInt32 v );
void SetUInt32_4( UInt32 v );
void SetString64_1( const char * v );
void SetString64_2( const char * v );
void SetString64_3( const char * v );
void SetString64_4( const char * v );
void SetString64_5( const char * v );
void SetString64_6( const char * v );
void SetIString64_1( const char * v );
void SetIString64_2( const char * v );
void SetText_1( const char * v );
void SetText_2( const char * v );
void SetBlob_1_Guid( const plUUID * v );
void SetBlob_2_Guid( const plUUID * v );
void * AllocBufferBlob_1( int size );
void * AllocBufferBlob_2( int size );
UInt32 GetID () const;
UInt8 GetType () const;
UInt32 GetPermissions () const;
UInt32 GetOwnerNodeID () const;
const plVaultPlayerInfoNode * GetOwnerNode () const;
UInt32 GetGroupNodeID () const;
const plVaultNode * GetGroupNode () const;
const plUnifiedTime * GetModifyTime () const;
UInt32 GetCreatorNodeID () const;
const plVaultPlayerInfoNode * GetCreatorNode () const;
const plUnifiedTime * GetCreateTime () const;
const plUnifiedTime * GetCreateAgeTime () const;
const char * GetCreateAgeName () const;
const plUUID * GetCreateAgeGuid () const;
Int32 GetInt32_1 () const;
Int32 GetInt32_2 () const;
Int32 GetInt32_3 () const;
Int32 GetInt32_4 () const;
UInt32 GetUInt32_1 () const;
UInt32 GetUInt32_2 () const;
UInt32 GetUInt32_3 () const;
UInt32 GetUInt32_4 () const;
const char * GetString64_1 () const;
const char * GetString64_2 () const;
const char * GetString64_3 () const;
const char * GetString64_4 () const;
const char * GetString64_5 () const;
const char * GetString64_6 () const;
const char * GetIString64_1 () const;
const char * GetIString64_2 () const;
const char * GetText_1 () const;
const char * GetText_2 () const;
std::string & GetBlob_1 ();
const std::string & GetBlob_1 () const;
void * GetBufferBlob_1 () const;
int GetBufferSizeBlob_1 () const;
const plUUID * GetBlob_1_Guid () const;
std::string & GetBlob_2 ();
const std::string & GetBlob_2 () const;
void * GetBufferBlob_2 () const;
int GetBufferSizeBlob_2 () const;
const plUUID * GetBlob_2_Guid () const;
public:
plVaultNode();
virtual ~plVaultNode();
bool IsADownstreamNode( UInt32 nodeID ) const;
/////////////////////////////////////////////////
// Vault Node API
#if 0
// Add child node
plVaultNodeRef * AddNode(
plVaultNode * node,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Find matching node on server and add it to this node.
// Optionally don't fetch children of this node.
bool LinkToNode(
const plVaultNode * templateNode,
int childFetchLevel=plVault::kFetchAllChildren,
bool allowCreate=true,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
bool LinkToNode(
UInt32 nodeID,
int childFetchLevel=plVault::kFetchAllChildren,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Remove child node
bool RemoveNode( const plVaultNode * node,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
bool RemoveNode( UInt32 nodeID,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Remove all child nodes
void RemoveAllNodes( void );
// Add/Save this node to vault
virtual void Save(
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Save this node and all child nodes that need saving.
// NOTE: Currently, the cb object is called back for
// each node saved.
void SaveAll(
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Send this node to the destination client node. will be received in it's inbox folder.
void SendTo(
UInt32 destClientNodeID,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
#endif
// Get an iterator to this node's children
plVaultNodeIterator GetIterator( void );
#if 0
// Get child node count
int GetNodeCount( void ) const { return fChildNodes.size(); }
// Get all child nodes.
void GetNodes( plVault::NodeRefVec & out );
// Get child node by ID
bool GetNode( UInt32 nodeID, plVaultNodeRef *& out ) const;
// Get child node matching template node
bool FindNode( const plVaultNode * templateNode, plVaultNodeRef *& out ) const;
// Get all matching child nodes
bool FindNodes( const plVaultNode * templateNode, plVault::NodeRefVec & out ) const;
// Get first matching node recursively among children
bool FindNodeRecurse( const plVaultNode * templateNode, plVaultNodeRef *& out ) const;
// Returns true if node is a child of this node
bool HasNode( UInt32 nodeID );
bool HasNode( const plVaultNode * templateNode );
// true if node needs saving
bool Modified( void ) const;
void SetModified( bool b );
// Get the client ID from my Vault client.
UInt32 GetClientID( void ) const;
// application data keyed to this node. not stored.
void SetUserData( UInt32 v ) { fUserData=v; }
UInt32 GetUserData( void ) const { return fUserData; }
#endif
/////////////////////////////////////////////////
#if 0
void Read( hsStream * s, hsResMgr * mgr );
void Write( hsStream * s, hsResMgr * mgr );
virtual void CopyFrom( const plVaultNode * other, bool forceCopyAllFields=false );
virtual std::string AsStdString( int level=0 ) const;
std::string FieldsAsStdString( void ) const;
void Dump( int level=0, bool displaySeen=false, bool beenSeen=true, plStatusLog * log=nil ) const;
void GetChildNodes( const plVault::NodeRefVec *& out ) const { out=&fChildNodes; }
virtual std::string AsHtmlForm( const char * action ) { return ""; }
bool FromHtmlPost( plURL & url ) { return false; }
#endif
private:
plVaultNode( const plVaultNode & );
plVaultNode & operator =( const plVaultNode & );
};
//============================================================================
//============================================================================
//============================================================================
//============================================================================
#if 0
////////////////////////////////////////////////////////////////////
class plVaultFolderNode : public plVaultNode
{
public:
enum FieldMap
{
kFolderType = kInt32_1,
kFolderName = kString64_1,
};
plVaultFolderNode();
~plVaultFolderNode();
CLASSNAME_REGISTER( plVaultFolderNode );
GETINTERFACE_ANY( plVaultFolderNode, plVaultNode );
void SetFolderType( int type ) { ISetInt32_1( type ); }
int GetFolderType( void ) const { return IGetInt32_1();}
void SetFolderName( const char * v ) { ISetString64_1( v ); }
const char * GetFolderName( void ) const{ return IGetString64_1();}
std::string AsStdString( int level=0 ) const;
std::string AsHtmlForm( const char * action );
};
////////////////////////////////////////////////////////////////////
class plMipmap;
class plVaultImageNode : public plVaultNode
{
friend class plNetClientVNodeMgr;
plMipmap * fMipmap;
void ISetMipmap( plMipmap * v ) { fMipmap=v; }
plMipmap * IGetMipmap( void ) const { return fMipmap; }
public:
enum FieldMap
{
kImageType = kInt32_1,
kImageTitle = kString64_1,
kImageData = kBlob_1,
};
enum ImageTypes { kJPEG=1 };
plVaultImageNode();
~plVaultImageNode();
CLASSNAME_REGISTER( plVaultImageNode );
GETINTERFACE_ANY( plVaultImageNode, plVaultNode );
const plMipmap * GetMipmap( void ) const { return fMipmap; }
// this override copies the mipmap ptr too.
void CopyFrom( const plVaultNode * other, bool forceCopyAllFields=false );
void SetImageType( int type ) { ISetInt32_1( type ); }
int GetImageType( void ) const { return IGetInt32_1(); }
void * AllocBuffer( int size ) { return IAllocBufferBlob_1( size ); }
void * GetBuffer( void ) const { return IGetBufferBlob_1(); }
int GetBufSize() const { return IGetBufferSizeBlob_1(); }
void SetTitle( const char * text ) { ISetString64_1( text ); }
const char * GetTitle( void ) const { return IGetString64_1(); }
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultTextNoteNode : public plVaultNode
{
public:
enum FieldMap
{
kNoteType = kInt32_1,
kNoteSubType = kInt32_2,
kNoteTitle = kString64_1,
kNoteText = kBlob_1,
};
plVaultTextNoteNode();
~plVaultTextNoteNode();
CLASSNAME_REGISTER( plVaultTextNoteNode );
GETINTERFACE_ANY( plVaultTextNoteNode, plVaultNode );
void SetText( const char * text );
const char * GetText( void ) const { return IGetBlob_1().c_str(); }
void SetTitle( const char * text ) { ISetString64_1( text ); }
const char * GetTitle( void ) const { return IGetString64_1(); }
void SetNoteType( Int32 type ) { ISetInt32_1( type ); }
Int32 GetNoteType( void ) const { return IGetInt32_1(); }
void SetNoteSubType( Int32 type ) { ISetInt32_2( type ); }
Int32 GetNoteSubType( void ) const { return IGetInt32_2(); }
// Device-specific:
plVaultFolderNode * GetDeviceInbox() const;
void SetDeviceInbox( const char * inboxName,
plVaultOperationCallback * cb=nil, UInt32 cbContext=0 );
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultSDLNode : public plVaultNode
{
mutable plStateDataRecord * fSDLDataRec; // for GetStateDataRecord()
public:
enum FieldMap
{
kName = kString64_1,
kIdent = kInt32_1, // pgmr-defined, from plVault::StandardNodes enum.
kSDLData = kBlob_1,
};
plVaultSDLNode();
~plVaultSDLNode();
CLASSNAME_REGISTER( plVaultSDLNode );
GETINTERFACE_ANY( plVaultSDLNode, plVaultNode );
void SetIdent( int v ) { ISetInt32_1( v ); }
int GetIdent() const { return IGetInt32_1(); }
void * AllocBuffer( int size ) { return IAllocBufferBlob_1( size ); }
void * GetBuffer( void ) const { return IGetBufferBlob_1(); }
int GetBufSize() const { return IGetBufferSizeBlob_1(); }
plStateDataRecord * GetStateDataRecord( UInt32 readOptions=0 ) const; // returned pointer will be valid until next call to this fxn, or until this node instance goes away.
void SetStateDataRecord( const plStateDataRecord * rec, UInt32 writeOptions=0 );
void InitStateDataRecord( const char * sdlRecName, UInt32 writeOptions=0 );
void DumpStateDataRecord( const char * msg=nil, bool dirtyOnly=false ) const;
// override to dump debug info.
void Save(
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultAgeInfoNode : public plVaultNode
{
mutable plVaultPlayerInfoListNode * fCanVisitFolder;
mutable plVaultPlayerInfoListNode * fAgeOwnersFolder;
mutable plVaultSDLNode * fAgeSDL;
mutable plVaultFolderNode * fChildAgesFolder;
mutable plUUID fAgeInstanceGuid;
mutable plNetServerSessionInfo fServerInfo;
mutable plAgeInfoStruct fAgeInfoStruct;
/////////////////////////////////
friend class pyVault;
friend class pyAgeVault;
friend class plVaultAgeInfoInitializationTask;
plVaultSDLNode * IGetAgeSDL() const;
plVaultAgeLinkNode * IGetLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const;
/////////////////////////////////
public:
enum FieldMap
{
kAgeFilename = kString64_1, // "Garden"
kAgeInstanceName = kString64_2, // "Eder Kemo"
kAgeUserDefinedName = kString64_3, // "Joe's"
kAgeInstanceGuid = kString64_4,
kAgeDescription = kText_1, // "Stay out!"
kAgeSequenceNumber = kInt32_1,
kIsPublic = kInt32_2,
kAgeLanguage = kInt32_3, // The language of the client that made this age
kAgeID = kUInt32_1,
kAgeCzarID = kUInt32_2,
kAgeInfoFlags = kUInt32_3,
};
enum AgeFlagBits // 32 bits max
{
kIsStartupNeighborhood = 1<<0,
};
plVaultAgeInfoNode();
~plVaultAgeInfoNode();
CLASSNAME_REGISTER( plVaultAgeInfoNode );
GETINTERFACE_ANY( plVaultAgeInfoNode, plVaultNode );
plVaultPlayerInfoListNode * GetCanVisitFolder() const;
plVaultPlayerInfoListNode * GetAgeOwnersFolder() const;
plVaultFolderNode * GetChildAgesFolder( void ) const;
plVaultAgeLinkNode * GetChildAgeLink( const plAgeInfoStruct * info ) const;
const plVaultSDLNode * GetAgeSDL() const { return IGetAgeSDL(); }
plVaultSDLNode * GetAgeSDL() { return IGetAgeSDL(); }
plVaultPlayerInfoNode * GetCzar() const;
const char * GetAgeFilename() const { return IGetString64_1(); }
void SetAgeFilename( const char * v ) { ISetString64_1( v ); }
const char * GetAgeInstanceName() const { return IGetString64_2(); }
void SetAgeInstanceName( const char * v ) { ISetString64_2( v ); }
const char * GetAgeUserDefinedName() const { return IGetString64_3(); }
void SetAgeUserDefinedName( const char * v ) { ISetString64_3( v ); }
const plUUID * GetAgeInstanceGuid() const { fAgeInstanceGuid.FromString( IGetString64_4() ); return &fAgeInstanceGuid; }
void SetAgeInstanceGuid( const plUUID * guid ) { fAgeInstanceGuid.CopyFrom( guid ); ISetString64_4( fAgeInstanceGuid.AsString() ); }
const char * GetAgeDescription() const { return IGetText_1(); }
void SetAgeDescription( const char * v ) { ISetText_1( v ); }
Int32 GetSequenceNumber() const { return IGetInt32_1(); }
void SetSequenceNumber( Int32 v ) { ISetInt32_1( v ); }
UInt32 GetAgeID() const { return IGetUInt32_1(); }
void SetAgeID( UInt32 v ) { ISetUInt32_1( v ); }
// aka mayor
UInt32 GetCzarID() const { return IGetUInt32_2(); }
void SetCzarID( UInt32 v ) { ISetUInt32_2( v ); }
bool IsPublic() const { return ( IGetInt32_2()!=0 ); }
// no glue for this one. Use plVaultAgeMgr::SetAgePublic() instead.
void ISetPublic( bool v ) { ISetInt32_2( v ); }
Int32 GetAgeLanguage() const { return IGetInt32_3(); }
void SetAgeLanguage( Int32 v ) { ISetInt32_3( v ); }
bool GetAgeFlag( UInt32 bit ) const { return ( IGetUInt32_3()&bit )!=0; }
void SetAgeFlag( UInt32 bit, bool on=true )
{ if ( on ) ISetUInt32_3( IGetUInt32_3()|bit );
else ISetUInt32_3( IGetUInt32_3()&~bit );
}
// helpers for linking.
const plNetServerSessionInfo * AsServerInfo() const;
const plAgeInfoStruct * AsAgeInfoStruct() const;
// helpers for init
void FromAgeInfoStruct( const plAgeInfoStruct * ageInfo );
// other helpers
const char * GetDisplayName() const;
// debug
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultAgeInfoListNode : public plVaultFolderNode
{
public:
enum FieldMap
{
};
plVaultAgeInfoListNode();
~plVaultAgeInfoListNode();
CLASSNAME_REGISTER( plVaultAgeInfoListNode );
GETINTERFACE_ANY( plVaultAgeInfoListNode, plVaultFolderNode );
bool HasAge( UInt32 AgeID );
bool AddAge( UInt32 AgeID );
void RemoveAge( UInt32 AgeID );
};
////////////////////////////////////////////////////////////////////
class plVaultAgeLinkNode : public plVaultNode
{
mutable plVaultAgeInfoNode * fAgeInfo;
public:
enum FieldMap
{
kLocked = kInt32_1, // locked on psnl bookshelf
kVolatile = kInt32_2, // volatile on psnl bookshelf
kSpawnPoints = kBlob_1, // aka treasure stones.
};
plVaultAgeLinkNode();
~plVaultAgeLinkNode();
CLASSNAME_REGISTER( plVaultAgeLinkNode );
GETINTERFACE_ANY( plVaultAgeLinkNode, plVaultNode );
plVaultAgeInfoNode * GetAgeInfo() const;
void SetAgeInfo( plVaultAgeInfoNode * v );
// locked on psnl age bookshelf
void SetLocked( bool v ) { ISetInt32_1( v?1:0 ); }
bool GetLocked() const { return ( IGetInt32_1()!=0 ); }
// volatile on psnl age bookshelf
void SetVolatile( bool v ) { ISetInt32_2( v?1:0 ); }
bool GetVolatile() const { return ( IGetInt32_2()!=0 ); }
// spawn points
void AddSpawnPoint( const plSpawnPointInfo & point ); // will only add if not there already.
void RemoveSpawnPoint( const char * spawnPtName );
bool HasSpawnPoint( const char * spawnPtName ) const;
bool HasSpawnPoint( const plSpawnPointInfo & point ) const; // compares spawn name only, not title.
void GetSpawnPoints( plSpawnPointVec & out ) const;
void SetSpawnPoints( const plSpawnPointVec & in );
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultChronicleNode : public plVaultNode
{
public:
enum FieldMap
{
kEntryType = kInt32_1,
kEntryName = kString64_1,
kEntryValue = kText_1,
};
plVaultChronicleNode();
~plVaultChronicleNode();
CLASSNAME_REGISTER( plVaultChronicleNode );
GETINTERFACE_ANY( plVaultChronicleNode, plVaultNode );
void SetName( const char * text ) { ISetString64_1( text ); }
const char * GetName( void ) const { return IGetString64_1(); }
void SetValue( const char * text ) { ISetText_1( text ); }
const char * GetValue( void ) const { return IGetText_1(); }
void SetEntryType( UInt32 type ) { ISetInt32_1( type ); }
UInt32 GetEntryType( void ) const { return IGetInt32_1(); }
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultPlayerInfoNode : public plVaultNode
{
mutable plUUID fGuid; // used with GetAgeGuid() only.
public:
enum FieldMap
{
kPlayerID = kUInt32_1,
kPlayerName = kIString64_1,
kAgeInstanceName = kString64_1, // name of age player is currently in
kAgeInstanceGuid = kString64_2, // guid of age player is currently in
kOnline = kInt32_1, // whether or not player is online
};
plVaultPlayerInfoNode();
~plVaultPlayerInfoNode();
CLASSNAME_REGISTER( plVaultPlayerInfoNode );
GETINTERFACE_ANY( plVaultPlayerInfoNode, plVaultNode );
// player ID
void SetPlayerID( UInt32 v );
UInt32 GetPlayerID( void ) const { return IGetUInt32_1(); }
// player name
void SetPlayerName( const char * text );
const char * GetPlayerName( void ) const { return IGetIString64_1(); }
// age the player is currently in, if any.
void SetAgeInstanceName( const char * v );
const char * GetAgeInstanceName( void ) const;
void SetAgeGuid( const plUUID * v);
const plUUID * GetAgeGuid( void ) const;
// online status
void SetOnline( bool b );
bool IsOnline( void ) const { return IGetInt32_1()!=0; }
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultPlayerInfoListNode : public plVaultFolderNode
{
void ISortPlayers( plNodeRefCompareProc proc );
void ILocalNodeAdded( plVaultNodeRef * nodeRef );
public:
enum FieldMap
{
};
plVaultPlayerInfoListNode();
~plVaultPlayerInfoListNode();
CLASSNAME_REGISTER( plVaultPlayerInfoListNode );
GETINTERFACE_ANY( plVaultPlayerInfoListNode, plVaultFolderNode );
bool HasPlayer( UInt32 playerID );
bool AddPlayer( UInt32 playerID );
void RemovePlayer( UInt32 playerID );
plVaultPlayerInfoNode * GetPlayer( UInt32 playerID );
void SetPlayers( const plVault::IDVec & playerIDs );
void SortBy( plNodeRefCompareProc proc ) { ISortPlayers( proc ); }
void Sort();
};
////////////////////////////////////////////////////////////////////
class plVaultMgrNode : public plVaultNode
{
friend class plVaultServer;
friend class plVaultConnectTask;
friend class plVNodeMgrInitializationTask;
mutable plVaultFolderNode * fMyInboxFolder;
mutable plVaultSystemNode * fSystemNode;
public:
enum FieldMap
{
};
plVaultMgrNode();
~plVaultMgrNode();
CLASSNAME_REGISTER( plVaultMgrNode );
GETINTERFACE_ANY( plVaultMgrNode, plVaultNode );
plVaultFolderNode * GetInbox( void ) const;
plVaultSystemNode * GetSystemNode() const;
};
////////////////////////////////////////////////////////////////////
class plVaultPlayerNode : public plVaultMgrNode
{
mutable plVaultPlayerInfoNode * fPlayerInfo;
mutable plVaultFolderNode * fAvatarOutfitFolder;
mutable plVaultFolderNode * fAvatarClosetFolder;
mutable plVaultFolderNode * fChronicleFolder;
mutable plVaultFolderNode * fAgeJournalsFolder;
mutable plVaultPlayerInfoListNode * fIgnoreListFolder;
mutable plVaultPlayerInfoListNode * fBuddyListFolder;
mutable plVaultPlayerInfoListNode * fPeopleIKnowAboutFolder;
mutable plVaultFolderNode * fAgesICanVisitFolder;
mutable plVaultFolderNode * fAgesIOwnFolder;
mutable plVaultFolderNode * fInviteFolder;
mutable plUUID fAcctUUID;
plVaultAgeLinkNode * IFindLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const;
void IRemoveLink( plVaultFolderNode * folder, const plUUID * guid );
public:
enum FieldMap
{
kPlayerName = kIString64_1,
kAvatarShapeName = kString64_1,
kDisabled = kInt32_2,
kOnlineTime = kUInt32_2, // seconds
kAccountUUID = kIString64_2,
};
plVaultPlayerNode();
~plVaultPlayerNode();
CLASSNAME_REGISTER( plVaultPlayerNode );
GETINTERFACE_ANY( plVaultPlayerNode, plVaultMgrNode );
plVaultPlayerInfoNode * GetPlayerInfo( void ) const;
plVaultFolderNode * GetAvatarOutfitFolder( void ) const;
plVaultFolderNode * GetAvatarClosetFolder( void ) const;
plVaultFolderNode * GetChronicleFolder( void ) const;
plVaultFolderNode * GetAgeJournalsFolder( void ) const;
plVaultPlayerInfoListNode * GetIgnoreListFolder( void ) const;
plVaultPlayerInfoListNode * GetBuddyListFolder( void ) const;
plVaultPlayerInfoListNode * GetPeopleIKnowAboutFolder( void ) const;
plVaultFolderNode * GetAgesICanVisitFolder( void ) const;
plVaultFolderNode * GetAgesIOwnFolder( void ) const;
plVaultFolderNode * GetInviteFolder( void ) const;
plVaultAgeLinkNode * GetLinkToMyNeighborhood() const;
plVaultAgeLinkNode * GetLinkToCity() const;
///////////////
// Owned ages
plVaultAgeLinkNode * GetOwnedAgeLink( const plAgeInfoStruct * info, bool skipVolatile=false ) const;
void RemoveOwnedAgeLink( const plUUID * guid );
// Visit ages
plVaultAgeLinkNode * GetVisitAgeLink( const plAgeInfoStruct * info ) const;
void RemoveVisitAgeLink( const plUUID * guid );
///////////////
// Chronicle
plVaultChronicleNode * FindChronicleEntry( const char * entryName );
// player name
void SetPlayerName( const char * v );
const char * GetPlayerName( void ) const { return IGetIString64_1(); }
// avatar shape name
void SetAvatarShapeName( const char * v );
const char * GetAvatarShapeName( void ) const{return IGetString64_1(); }
// disabled?
void SetDisabled( bool v ) { ISetInt32_2( v ); }
bool IsDisabled( void ) const { return IGetInt32_2()!=0; }
// account ID
void SetAccountUUID( const plUUID * v );
const plUUID * GetAccountUUID( void ) const;
// online time accumulator (plUnifiedTime.GetSecs())
void SetOnlineTime( UInt32 v ) { ISetUInt32_2( v ); }
UInt32 GetOnlineTime( void ) const { return IGetUInt32_2(); }
void IncOnlineTime( UInt32 v ) { SetOnlineTime( GetOnlineTime()+v ); }
// override to also save player info node.
void Save(
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultAgeNode : public plVaultMgrNode
{
mutable plUUID fAgeGuid;
mutable plVaultAgeInfoNode * fAgeInfo;
mutable plVaultFolderNode * fAgeDevicesFolder;
mutable plVaultFolderNode * fSubAgesFolder;
mutable plVaultPlayerInfoListNode * fPeopleIKnowAboutFolder;
mutable plVaultFolderNode * fChronicleFolder;
// used only with personal ages
mutable plVaultFolderNode * fAgesIOwnFolder;
// used only with nexus age
mutable plVaultFolderNode * fPublicAgesFolder;
plVaultAgeLinkNode * IGetLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const;
public:
enum FieldMap
{
kAgeGuid = kString64_1,
};
plVaultAgeNode();
~plVaultAgeNode();
CLASSNAME_REGISTER( plVaultAgeNode );
GETINTERFACE_ANY( plVaultAgeNode, plVaultMgrNode );
plVaultAgeInfoNode * GetAgeInfo() const;
plVaultFolderNode * GetAgeDevicesFolder( void ) const;
plVaultFolderNode * GetSubAgesFolder( void ) const;
// age chronicle
plVaultFolderNode * GetChronicleFolder( void ) const;
// People who have published to devices in this age
plVaultPlayerInfoListNode * GetPeopleIKnowAboutFolder( void ) const;
// PERSONAL AGE SPECIFIC
plVaultFolderNode * GetAgesIOwnFolder( void ) const;
// NEXUS AGE SPECIFIC
plVaultFolderNode * GetPublicAgesFolder( void ) const;
// To publish a node to a device, get its device inbox ID, then
// call node->SendTo( deviceInboxID );
plVaultAgeLinkNode * GetSubAgeLink( const plAgeInfoStruct * info ) const;
// AGE DEVICES. AKA IMAGERS, WHATEVER.
// Add a new device.
void AddDevice( const char * deviceName,
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
// Remove a device.
void RemoveDevice( const char * deviceName );
// True if device exists in age.
bool HasDevice( const char * deviceName );
// Get a device.
plVaultTextNoteNode * GetDevice( const char * deviceName );
// age guid
const plUUID * GetAgeGuid() const { fAgeGuid.FromString( IGetString64_1() ); return &fAgeGuid; }
void SetAgeGuid( const plUUID * guid );
// Age chronicle
plVaultChronicleNode * FindChronicleEntry( const char * entryName );
// override to also save age info node.
void Save(
plVaultOperationCallback * cb=nil,
UInt32 cbContext=0 );
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultAdminNode : public plVaultMgrNode
{
mutable plVaultFolderNode * fAllAgeSDLEventInboxesFolder;
public:
enum FieldMap
{
};
plVaultAdminNode();
~plVaultAdminNode();
CLASSNAME_REGISTER( plVaultAdminNode );
GETINTERFACE_ANY( plVaultAdminNode, plVaultMgrNode );
plVaultFolderNode * GetAllAgeSDLEventInboxesFolder( void ) const;
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
class plVaultMarkerNode : public plVaultNode
{
public:
enum FieldMap
{
kAgeName = kCreateAgeName,
kMarkerText = kText_1,
kGPSTorans = kInt32_1,
kGPSHSpans = kInt32_2,
kGPSVSpans = kInt32_3,
kMarkerPosX = kUInt32_1,
kMarkerPosY = kUInt32_2,
kMarkerPosZ = kUInt32_3,
};
plVaultMarkerNode();
~plVaultMarkerNode();
CLASSNAME_REGISTER(plVaultMarkerNode);
GETINTERFACE_ANY(plVaultMarkerNode, plVaultNode);
void SetAge(const char* ageName) { ISetCreateAgeName(ageName); }
const char* GetAge() const { return IGetCreateAgeName(); }
void SetPosition(const hsPoint3& pos);
hsPoint3 GetPosition() const;
void SetText(const char* text) { ISetText_1(text); }
const char* GetText() const { return IGetText_1(); }
void SetGPS(Int32 t, Int32 h, Int32 v) { ISetInt32_1(t);ISetInt32_2(h);ISetInt32_3(v); }
Int32 GetGPSTorans() const { return IGetInt32_1(); }
Int32 GetGPSHSpans() const { return IGetInt32_2(); }
Int32 GetGPSVSpans() const { return IGetInt32_3(); }
std::string AsStdString(int level=0) const;
};
////////////////////////////////////////////////////////////////////
class plVaultMarkerListNode : public plVaultFolderNode
{
public:
enum FieldMap
{
kOwnerID = kUInt32_1,
kOwnerName = kString64_2,
kGameType = kInt32_1,
kRoundLength = kInt32_2,
};
plVaultMarkerListNode();
~plVaultMarkerListNode();
CLASSNAME_REGISTER(plVaultMarkerListNode);
GETINTERFACE_ANY(plVaultMarkerListNode, plVaultFolderNode);
void SetOwnerName( const char * v ) { ISetString64_2( v ); }
const char * GetOwnerName( void ) const{ return IGetString64_2();}
Int32 GetGameType() const { return IGetInt32_1(); }
void SetGameType( Int32 v ) { ISetInt32_1( v ); }
Int32 GetRoundLength() const { return IGetInt32_2(); }
void SetRoundLength( Int32 v ) { ISetInt32_2( v ); }
std::string AsStdString(int level=0) const;
};
////////////////////////////////////////////////////////////////////
//
// A node that ALL vault mgrs get - for system wide info
//
class plVaultSystemNode : public plVaultNode
{
mutable plVaultFolderNode * fGlobalInboxFolder;
public:
enum FieldMap
{
kCCRAwayStatus = kInt32_1
};
plVaultSystemNode();
CLASSNAME_REGISTER( plVaultSystemNode);
GETINTERFACE_ANY( plVaultSystemNode, plVaultNode );
void SetCCRAwayStatus( bool b) { ISetInt32_1( b); }
int GetCCRAwayStatus( void ) const { return IGetInt32_1();}
plVaultFolderNode * GetGlobalInbox( void ) const;
std::string AsStdString( int level=0 ) const;
};
////////////////////////////////////////////////////////////////////
// Vault Server VNode
// Makes sure nodes like AllPlayers exist.
class plNetVaultServerNode : public plVaultMgrNode
{
friend class plNetVaultServerInitializationTask;
mutable plVaultAgeInfoNode * fCityInfo;
UInt32 fAllPlayersFolderID;
UInt32 fAllAgeGlobalSDLNodesFolderID;
UInt32 fPublicAgesFolderID;
public:
plNetVaultServerNode();
~plNetVaultServerNode();
CLASSNAME_REGISTER( plNetVaultServerNode );
GETINTERFACE_ANY( plNetVaultServerNode, plVaultMgrNode );
UInt32 GetAllPlayersFolderID() const { return fAllPlayersFolderID; }
UInt32 GetAllAgeGlobalSDLNodesFolderID() const { return fAllAgeGlobalSDLNodesFolderID; }
UInt32 GetPublicAgesFolderID() const { return fPublicAgesFolderID; }
std::string AsStdString( int level=0 ) const;
};
#endif // 0
//============================================================================
//============================================================================
//============================================================================
//============================================================================
#endif // plVaultNode_h_inc
#endif