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.
2743 lines
76 KiB
2743 lines
76 KiB
/*==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==*/ |
|
#if 0 |
|
#include "hsTemplates.h" |
|
#include "hsStlUtils.h" |
|
#include "plVaultNode.h" |
|
#include "plVaultNodeIterator.h" |
|
#include "../pnMessage/plMessage.h" |
|
#include "../plNetMessage/plNetMessage.h" |
|
#include "../plNetCommon/plNetCommon.h" |
|
#include "../plStatusLog/plStatusLog.h" |
|
#include "../plSDL/plSDL.h" |
|
#include <sstream> |
|
#include "hsGeometry3.h" |
|
#include "hsStringTokenizer.h" |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
#define plSafeGetLog() if (fMyNodeMgr) fMyNodeMgr->GetStatusLog() |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
|
|
bool plVaultNode::MatchesNode::operator()( const plVaultNode * node ) const |
|
{ |
|
if ( !node ) |
|
return false; |
|
|
|
bool matches = true; |
|
|
|
if ( fNode->IIsFieldFlagSet( plVaultNode::kID ) ) |
|
{ |
|
matches &= ( fNode->GetID()==node->GetID() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kType ) ) |
|
{ |
|
matches &= ( fNode->GetType()==node->GetType() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kPermissions ) ) |
|
{ |
|
matches &= ( fNode->GetPermissions()==node->GetPermissions() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kOwnerNodeID ) ) |
|
{ |
|
matches &= ( fNode->GetOwnerNodeID()==node->GetOwnerNodeID() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kGroupNodeID ) ) |
|
{ |
|
matches &= ( fNode->GetGroupNodeID()==node->GetGroupNodeID() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kModifyTime ) ) |
|
{ |
|
matches &= ( *fNode->GetModifyTime()==*node->GetModifyTime() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreatorNodeID ) ) |
|
{ |
|
matches &= ( fNode->GetCreatorNodeID()==node->GetCreatorNodeID() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreateTime ) ) |
|
{ |
|
matches &= ( *fNode->GetCreateTime()==*node->GetCreateTime() ); |
|
} |
|
// if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreateAgeCoords ) ) |
|
// { |
|
// hsAssert( false, "Compare age coords not supported" ); |
|
// } |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreateAgeTime ) ) |
|
{ |
|
matches &= ( *fNode->GetCreateAgeTime()==*node->GetCreateAgeTime() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreateAgeName ) ) |
|
{ |
|
matches &= ( strcmp( fNode->GetCreateAgeName(), node->GetCreateAgeName() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kCreateAgeGuid ) ) |
|
{ |
|
matches &= ( fNode->GetCreateAgeGuid()->IsEqualTo( node->GetCreateAgeGuid() ) ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kInt32_1 ) ) |
|
{ |
|
matches &= ( fNode->IGetInt32_1()==node->IGetInt32_1() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kInt32_2 ) ) |
|
{ |
|
matches &= ( fNode->IGetInt32_2()==node->IGetInt32_2() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kInt32_3 ) ) |
|
{ |
|
matches &= ( fNode->IGetInt32_3()==node->IGetInt32_3() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kInt32_4 ) ) |
|
{ |
|
matches &= ( fNode->IGetInt32_4()==node->IGetInt32_4() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kUInt32_1 ) ) |
|
{ |
|
matches &= ( fNode->IGetUInt32_1()==node->IGetUInt32_1() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kUInt32_2 ) ) |
|
{ |
|
matches &= ( fNode->IGetUInt32_2()==node->IGetUInt32_2() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kUInt32_3 ) ) |
|
{ |
|
matches &= ( fNode->IGetUInt32_3()==node->IGetUInt32_3() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kUInt32_4 ) ) |
|
{ |
|
matches &= ( fNode->IGetUInt32_4()==node->IGetUInt32_4() ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_1 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_1(), node->IGetString64_1() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_2 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_2(), node->IGetString64_2() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_3 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_3(), node->IGetString64_3() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_4 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_4(), node->IGetString64_4() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_5 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_5(), node->IGetString64_5() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kString64_6 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetString64_6(), node->IGetString64_6() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kIString64_1 ) ) |
|
{ |
|
matches &= ( stricmp( fNode->IGetIString64_1(), node->IGetIString64_1() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kIString64_2 ) ) |
|
{ |
|
matches &= ( stricmp( fNode->IGetIString64_2(), node->IGetIString64_2() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kText_1 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetText_1(), node->IGetText_1() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kText_2 ) ) |
|
{ |
|
matches &= ( strcmp( fNode->IGetText_2(), node->IGetText_2() )==0 ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kBlob_1 ) ) |
|
{ |
|
// hsAssert( false, "Compare blobs not supported" ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kBlob_2 ) ) |
|
{ |
|
// hsAssert( false, "Compare blobs not supported" ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kBlob_1_Guid ) ) |
|
{ |
|
matches &= ( fNode->IGetBlob_1_Guid()->IsEqualTo( node->IGetBlob_1_Guid() ) ); |
|
} |
|
if ( matches && fNode->IIsFieldFlagSet( plVaultNode::kBlob_2_Guid ) ) |
|
{ |
|
matches &= ( fNode->IGetBlob_2_Guid()->IsEqualTo( node->IGetBlob_2_Guid() ) ); |
|
} |
|
|
|
return matches; |
|
} |
|
|
|
bool plVaultNode::MatchesNode::operator()( const plVaultNodeRef * nodeRef ) const |
|
{ |
|
return operator()( nodeRef->GetChild() ); |
|
} |
|
|
|
plVaultNode::plVaultNode() |
|
: fID( 0 ) |
|
, fType( 0 ) |
|
, fPermissions( 0 ) |
|
, fOwnerNodeID( 0 ) |
|
, fGroupNodeID( 0 ) |
|
, fCreatorNodeID( 0 ) |
|
, fInt32_1( 0 ) |
|
, fInt32_2( 0 ) |
|
, fInt32_3( 0 ) |
|
, fInt32_4( 0 ) |
|
, fUInt32_1( 0 ) |
|
, fUInt32_2( 0 ) |
|
, fUInt32_3( 0 ) |
|
, fUInt32_4( 0 ) |
|
, fOwnerNode( nil ) |
|
, fGroupNode( nil ) |
|
, fCreatorNode( nil ) |
|
, fPersistent( true ) |
|
, fSaving( false ) |
|
, fInitialized( false ) |
|
, fUserData( 0 ) |
|
, fMyNodeMgr( nil ) |
|
{ |
|
} |
|
|
|
plVaultNode::~plVaultNode() |
|
{ |
|
IFailPendingSaves(); |
|
std::for_each( fChildNodes.begin(), fChildNodes.end(), xtl::delete_ptr() ); |
|
fChildNodes.clear(); |
|
} |
|
|
|
bool plVaultNode::IIsFieldFlagSet( int b ) const |
|
{ |
|
return fFieldFlags.IsBitSet( b )?true:false; |
|
} |
|
|
|
void plVaultNode::IGotUpdated( void ) |
|
{ |
|
hsLogEntry( plSafeGetLog()->AddLineF( "Updated remotely: %s", AsStdString().c_str() ) ); |
|
} |
|
|
|
|
|
UInt32 plVaultNode::GetID( void ) const |
|
{ |
|
return fID; |
|
} |
|
|
|
void plVaultNode::ISetID( UInt32 v ) |
|
{ |
|
ISetFieldFlag( kID ); |
|
fID = v; |
|
} |
|
|
|
|
|
const plVaultPlayerInfoNode * plVaultNode::GetOwnerNode( void ) const |
|
{ |
|
if (!fMyNodeMgr) |
|
return nil; |
|
|
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( fOwnerNodeID ); |
|
plVaultNode * result; |
|
fMyNodeMgr->FindNode( &templateNode, result ); |
|
return plVaultPlayerInfoNode::ConvertNoRef( result ); |
|
} |
|
|
|
|
|
const plVaultPlayerInfoNode * plVaultNode::GetCreatorNode( void ) const |
|
{ |
|
if (!fMyNodeMgr) |
|
return nil; |
|
|
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( fCreatorNodeID ); |
|
plVaultNode * result; |
|
fMyNodeMgr->FindNode( &templateNode, result ); |
|
return plVaultPlayerInfoNode::ConvertNoRef( result ); |
|
} |
|
|
|
const plVaultNode * plVaultNode::GetGroupNode( void ) const |
|
{ |
|
return nil; |
|
} |
|
|
|
|
|
bool plVaultNode::IHasFieldFlagsSet( void ) |
|
{ |
|
fFieldFlags.Compact(); |
|
return fFieldFlags.GetSize()>0; |
|
} |
|
|
|
bool plVaultNode::HasValidID( void ) const |
|
{ |
|
return ( fID>0 ) && ( !fPersistent || ( fPersistent && ( fID>=plVault::kFirstStoredNodeID ) ) ); |
|
} |
|
|
|
bool plVaultNode::IsStored( void ) const |
|
{ |
|
if( !fMyNodeMgr ) |
|
{ |
|
return fID>plVault::kFirstStoredNodeID; |
|
} |
|
else |
|
{ |
|
return ( fMyNodeMgr->IAmOnline() && ( ( fID>plVault::kFirstStoredNodeID ) || fSaving ) ) |
|
|| ( !fMyNodeMgr->IAmOnline() ); // if not online then, sure... it's stored.. yeah. |
|
} |
|
} |
|
|
|
bool plVaultNode::IsMgrNode( void ) const |
|
{ |
|
return ( IsStored() && fType>plVault::kNodeType_VNodeMgrLow && fType<plVault::kNodeType_VNodeMgrHigh ); |
|
} |
|
|
|
void plVaultNode::IDoPendingSave( void ) |
|
{ |
|
if ( !fPendingSaves.empty() ) |
|
{ |
|
plVaultSaveNodeTask * task = fPendingSaves.front(); |
|
fPendingSaves.erase( fPendingSaves.begin() ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( "Starting pending save operation on node %lu", GetID() )); |
|
task->Start(); |
|
} |
|
} |
|
|
|
void plVaultNode::IFailPendingSaves() |
|
{ |
|
while ( !fPendingSaves.empty() ) |
|
{ |
|
plVaultSaveNodeTask * task = fPendingSaves.front(); |
|
fPendingSaves.erase( fPendingSaves.begin() ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( "Aborting pending save operation on node %lu", GetID() )); |
|
task->TaskComplete( false ); |
|
} |
|
} |
|
|
|
void plVaultNode::IAddPendingSave( plVaultSaveNodeTask * task ) |
|
{ |
|
hsLogEntry(plSafeGetLog()->AddLineF( "Adding pending save operation to node %lu", GetID() )); |
|
fPendingSaves.push_back( task ); |
|
} |
|
|
|
|
|
static bool CompareNodeRefCreateTimes( const plVaultNodeRef * A, const plVaultNodeRef * B ) |
|
{ |
|
return ( A->GetCreateTime()->GetSecs()<B->GetCreateTime()->GetSecs() ); |
|
} |
|
|
|
plVaultNodeRef * plVaultNode::ILocalAddNode( plVaultNode * node, bool notify ) |
|
{ |
|
plVaultNodeRef nodeRef; |
|
nodeRef.ISetChildNode( node ); |
|
return ILocalAddNode( &nodeRef, notify ); |
|
} |
|
|
|
plVaultNodeRef * plVaultNode::ILocalAddNode( const plVaultNodeRef * in, bool notify ) |
|
{ |
|
hsAssert( in->GetChildID()!=0, "ILocalAddNode: Invalid child ID" ); |
|
|
|
if ( in->fChildID<plVault::kFirstStoredNodeID ) |
|
{ |
|
int xx=0; |
|
} |
|
|
|
if ( IIsAnUpstreamNode( in->GetChildID() ) ) |
|
{ |
|
// plSafeGetLog()->AddLine( "ILocalAddNode: node being added as a child exists above me in family tree!" ); |
|
hsAssert( false, "ILocalAddNode: node being added as a child exists above me in family tree!" ); |
|
return nil; |
|
} |
|
|
|
plVaultNodeRef * nodeRef; |
|
bool found = GetNode( in->GetChildID(), nodeRef ); |
|
if ( !found && fMyNodeMgr) |
|
{ |
|
nodeRef = fMyNodeMgr->CreateNodeRef(); |
|
nodeRef->CopyFrom( in ); |
|
nodeRef->ISetParentID( GetID() ); |
|
if ( in->GetChild() ) |
|
nodeRef->ISetChildNode( in->GetChild() ); |
|
// add node |
|
fChildNodes.push_back( nodeRef ); |
|
// sort nodes by create time |
|
std::sort( fChildNodes.begin(), fChildNodes.end(), CompareNodeRefCreateTimes ); |
|
// call internal notify |
|
ILocalNodeAdded( nodeRef ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( "Added child %lu to parent %lu", nodeRef->GetChildID(), nodeRef->GetParentID() )); |
|
// do callbacks |
|
if ( notify ) |
|
fMyNodeMgr->INotifyNodeRefAdded( nodeRef ); |
|
} |
|
return nodeRef; |
|
} |
|
|
|
bool plVaultNode::ILocalRemoveNode( UInt32 nodeID, bool notify ) |
|
{ |
|
plVaultNode tmp; |
|
tmp.ISetID( nodeID ); |
|
plVault::NodeRefVec::iterator it = |
|
std::find_if( fChildNodes.begin(), fChildNodes.end(), |
|
plVaultNode::MatchesNode( &tmp ) ); |
|
bool found = ( it!=fChildNodes.end() ); |
|
if ( found && fMyNodeMgr) |
|
{ |
|
plVaultNodeRef * nodeRef = *it; |
|
if ( notify ) |
|
fMyNodeMgr->INotifyRemovingNodeRef( nodeRef ); |
|
delete *it; |
|
fChildNodes.erase( it ); |
|
if ( notify ) |
|
fMyNodeMgr->INotifyNodeRefRemoved( nodeID, GetID() ); |
|
} |
|
return found; |
|
} |
|
|
|
bool plVaultNode::IIsAnUpstreamNode( UInt32 nodeID ) |
|
{ |
|
plVaultNode * node; |
|
if ( fMyNodeMgr && fMyNodeMgr->GetNode( nodeID, node ) ) |
|
return node->IIsADownstreamNode( GetID() ); |
|
return false; |
|
} |
|
|
|
bool plVaultNode::IIsADownstreamNode( UInt32 nodeID ) |
|
{ |
|
for ( int i=0; i<fChildNodes.size(); i++ ) |
|
{ |
|
if ( fChildNodes[i]->GetChildID()==nodeID ) |
|
return true; |
|
if ( fChildNodes[i]->GetChild()->IIsADownstreamNode( nodeID ) ) |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
plVaultNodeRef * plVaultNode::AddNode( plVaultNode * node, plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
if ( IsPersistent() && !IsStored() && node->IsPersistent() ) |
|
{ |
|
std::string msg; |
|
xtl::format( msg, "Tried to add persistent child to non-saved persistent parent. parent fSaving=%s", fSaving?"yep":"nope" ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( plStatusLog::kRed, "%s", msg.c_str() )); |
|
// hsAssert( false, msg.c_str() ); |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.OperationComplete( hsFail ); |
|
return false; |
|
} |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( node, nodeRef ) ) |
|
{ |
|
// we already have this child, short circuit. |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.SetCbFields( nodeRef->GetChild(), nodeRef ); |
|
cbHolder.OperationComplete( hsOK ); |
|
return nodeRef; |
|
} |
|
|
|
return fMyNodeMgr ? fMyNodeMgr->IAddNodeRef( node, GetID(), cb, cbContext ) : nil; // starts network operation |
|
} |
|
|
|
bool plVaultNode::LinkToNode( const plVaultNode * templateNode, int childFetchLevel, bool allowCreate, plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
if ( IsPersistent() && !IsStored() ) |
|
{ |
|
std::string msg; |
|
xtl::format( msg, "Tried to link a child to non-saved persistent parent. parent fSaving=%s", fSaving?"yep":"nope" ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( plStatusLog::kRed, "%s", msg.c_str() )); |
|
// hsAssert( false, msg.c_str() ); |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.OperationComplete( hsFail ); |
|
return false; |
|
} |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( templateNode, nodeRef ) ) |
|
{ |
|
// we already have this child, short circuit. |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.SetCbFields( nodeRef->GetChild(), nodeRef ); |
|
cbHolder.OperationComplete( hsOK ); |
|
return true; |
|
} |
|
|
|
// Can't allowCreate if template specified an ID, unless we aren't online. |
|
allowCreate &= ( fMyNodeMgr && !templateNode->IIsFieldFlagSet( plVaultNode::kID ) || !fMyNodeMgr->IAmOnline() ); |
|
|
|
fMyNodeMgr ? fMyNodeMgr->ILinkToNode( templateNode, childFetchLevel, allowCreate, GetID(), cb, cbContext ) : NULL_STMT; |
|
|
|
return true; |
|
} |
|
|
|
bool plVaultNode::LinkToNode( UInt32 nodeID, int childFetchLevel, plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
plVaultNode templateNode; |
|
templateNode.ISetID( nodeID ); |
|
return LinkToNode( &templateNode, childFetchLevel, false, cb,cbContext ); |
|
} |
|
|
|
bool plVaultNode::RemoveNode( const plVaultNode * node, plVaultOperationCallback * cb/*=nil*/, UInt32 cbContext/*=0 */) |
|
{ |
|
// remove by id |
|
if ( node->GetID()!=0 ) |
|
return RemoveNode( node->GetID(), cb, cbContext ); |
|
// remove by template match |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( node, nodeRef ) ) |
|
return RemoveNode( nodeRef->GetChildID(), cb, cbContext ); |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.OperationComplete( hsFail ); |
|
return false; |
|
} |
|
|
|
bool plVaultNode::RemoveNode( UInt32 nodeID, plVaultOperationCallback * cb/*=nil*/, UInt32 cbContext/*=0 */) |
|
{ |
|
fMyNodeMgr ? fMyNodeMgr->IRemoveNodeRef( nodeID, GetID(), cb, cbContext ) : NULL_STMT;// starts network operation |
|
return true; |
|
} |
|
|
|
void plVaultNode::GetNodes( plVault::NodeRefVec & out ) |
|
{ |
|
std::copy( fChildNodes.begin(), fChildNodes.end(), std::back_inserter( out ) ); |
|
} |
|
|
|
bool plVaultNode::GetNode( UInt32 nodeID, plVaultNodeRef *& out ) const |
|
{ |
|
plVaultNode tmp; |
|
tmp.ISetID( nodeID ); |
|
return FindNode( &tmp, out ); |
|
} |
|
|
|
bool plVaultNode::FindNode( const plVaultNode * templateNode, plVaultNodeRef *& out ) const |
|
{ |
|
plVaultNode tmp; |
|
if ( templateNode->IsStored() ) |
|
tmp.ISetID( templateNode->GetID() ); |
|
else |
|
tmp.CopyFrom( templateNode ); |
|
|
|
out = nil; |
|
plVault::NodeRefVec::const_iterator it = |
|
std::find_if( fChildNodes.begin(), fChildNodes.end(), |
|
plVaultNode::MatchesNode( &tmp ) ); |
|
bool found = ( it!=fChildNodes.end() ); |
|
if ( found ) |
|
out = *it; |
|
return found; |
|
} |
|
|
|
bool plVaultNode::FindNodes( const plVaultNode * templateNode, plVault::NodeRefVec & out ) const |
|
{ |
|
plVaultNode tmp; |
|
if ( templateNode->IsStored() ) |
|
tmp.ISetID( templateNode->GetID() ); |
|
else |
|
tmp.CopyFrom( templateNode ); |
|
|
|
int n = out.size(); |
|
MatchesNode matcher( &tmp ); |
|
for ( int i=0; i<fChildNodes.size(); i++ ) |
|
if ( matcher( fChildNodes[i] ) ) |
|
out.push_back( fChildNodes[i] ); |
|
return ( out.size()-n > 0 ); |
|
} |
|
|
|
bool plVaultNode::FindNodeRecurse( const plVaultNode * templateNode, plVaultNodeRef *& out ) const |
|
{ |
|
if ( !FindNode( templateNode, out ) ) |
|
{ |
|
for ( plVault::NodeRefVec::const_iterator it=fChildNodes.begin(); it!=fChildNodes.end(); ++it ) |
|
{ |
|
if ( (*it)->GetChild()->FindNodeRecurse( templateNode, out ) ) |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
|
|
bool plVaultNode::HasNode( UInt32 nodeID ) |
|
{ |
|
plVaultNode templateNode; |
|
templateNode.SetID( nodeID ); |
|
return HasNode( &templateNode ); |
|
} |
|
|
|
bool plVaultNode::HasNode( const plVaultNode * templateNode ) |
|
{ |
|
plVaultNodeRef * nodeRef; |
|
return FindNode( templateNode, nodeRef ); |
|
} |
|
|
|
bool plVaultNode::Modified( void ) const |
|
{ |
|
fFieldFlags.Compact(); |
|
return ( fFieldFlags.GetSize()>0 ); |
|
} |
|
|
|
void plVaultNode::SetModified( bool b ) |
|
{ |
|
if ( !b ) |
|
{ |
|
IClearAllFieldFlags(); |
|
} |
|
else |
|
{ |
|
ISetAllFieldFlags(); |
|
SetModifyTime( &plUnifiedTime::GetCurrentTime() ); |
|
} |
|
} |
|
|
|
|
|
|
|
UInt32 plVaultNode::GetClientID( void ) const |
|
{ |
|
if ( !fMyNodeMgr ) |
|
return 0; |
|
return fMyNodeMgr->GetClientID(); |
|
} |
|
|
|
|
|
void plVaultNode::Save( plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
if (Modified() && fMyNodeMgr) |
|
{ |
|
fMyNodeMgr->ISaveNode( this, cb, cbContext ); |
|
} |
|
else |
|
{ |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.OperationComplete( hsOK ); |
|
} |
|
} |
|
|
|
void plVaultNode::SaveAll( plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
for ( int i=0; i<fChildNodes.size(); i++ ) |
|
{ |
|
plVaultNodeRef * nodeRef = fChildNodes[i]; |
|
plVaultNode * child = nodeRef->GetChild(); |
|
child->SaveAll( cb, cbContext ); |
|
} |
|
Save( cb, cbContext ); |
|
} |
|
|
|
|
|
void plVaultNode::SendTo( UInt32 destClientNodeID, plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
if (!fMyNodeMgr) |
|
return; |
|
fMyNodeMgr->ISendNode( this, destClientNodeID, cb, cbContext ); |
|
} |
|
|
|
|
|
void plVaultNode::RemoveAllNodes( void ) |
|
{ |
|
plVault::IDVec ids; |
|
for ( plVaultNodeIterator nodeIt=GetIterator(); nodeIt; ++nodeIt ) |
|
{ |
|
ids.push_back( (*nodeIt)->GetChildID() ); |
|
} |
|
for ( int i=0; i<ids.size(); i++ ) |
|
{ |
|
RemoveNode( ids[i] ); |
|
} |
|
} |
|
|
|
|
|
plVaultNodeIterator plVaultNode::GetIterator( void ) |
|
{ |
|
return plVaultNodeIterator( this ); |
|
} |
|
|
|
|
|
// NOTE: IF YOU CHANGE plVaultNode STREAM FORMAT, BE SURE TO |
|
// INCREMENT VaultNodeVersion (ABOVE). |
|
void plVaultNode::Read( hsStream * s, hsResMgr * mgr ) |
|
{ |
|
hsAssert( s, "nil stream" ); |
|
|
|
fFieldFlags.Read( s ); |
|
|
|
// these fields are always streamed |
|
s->ReadSwap( &fID ); |
|
s->ReadSwap( &fType ); |
|
s->ReadSwap( &fPermissions ); |
|
s->ReadSwap( &fOwnerNodeID ); |
|
s->ReadSwap( &fGroupNodeID ); |
|
fModifyTime.Read( s ); |
|
// set these to nil in case their corresponding ID changed above. |
|
fOwnerNode = nil; |
|
fGroupNode = nil; |
|
|
|
// fields relating to creation of this node |
|
if ( IIsFieldFlagSet( kCreatorNodeID ) ) |
|
{ |
|
s->ReadSwap( &fCreatorNodeID ); |
|
fCreatorNode = nil; |
|
} |
|
if ( IIsFieldFlagSet( kCreateTime ) ) |
|
{ |
|
fCreateTime.Read( s ); |
|
} |
|
// if ( IIsFieldFlagSet( kCreateAgeCoords ) ) |
|
// { |
|
// fCreateAgeCoords.Read( s, mgr ); |
|
// } |
|
if ( IIsFieldFlagSet( kCreateAgeTime ) ) |
|
{ |
|
fCreateAgeTime.Read( s ); |
|
} |
|
if ( IIsFieldFlagSet( kCreateAgeName ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fCreateAgeName, s ); |
|
} |
|
if ( IIsFieldFlagSet( kCreateAgeGuid ) ) |
|
{ |
|
fCreateAgeGuid.Read( s ); |
|
} |
|
// generic fields |
|
if ( IIsFieldFlagSet( kInt32_1 ) ) |
|
{ |
|
s->ReadSwap( &fInt32_1 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_2 ) ) |
|
{ |
|
s->ReadSwap( &fInt32_2 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_3 ) ) |
|
{ |
|
s->ReadSwap( &fInt32_3 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_4 ) ) |
|
{ |
|
s->ReadSwap( &fInt32_4 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_1 ) ) |
|
{ |
|
s->ReadSwap( &fUInt32_1 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_2 ) ) |
|
{ |
|
s->ReadSwap( &fUInt32_2 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_3 ) ) |
|
{ |
|
s->ReadSwap( &fUInt32_3 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_4 ) ) |
|
{ |
|
s->ReadSwap( &fUInt32_4 ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_3 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_3, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_4 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_4, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_5 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_5, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_6 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fString64_6, s ); |
|
} |
|
if ( IIsFieldFlagSet( kIString64_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fIString64_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kIString64_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fIString64_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kText_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fText_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kText_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Peek( fText_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_1 ) ) |
|
{ |
|
UInt32 buflen; |
|
s->ReadSwap( &buflen ); |
|
IAllocBufferBlob_1( buflen ); |
|
if (buflen) |
|
s->Read( buflen,(void*)IGetBufferBlob_1() ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_2 ) ) |
|
{ |
|
UInt32 buflen; |
|
s->ReadSwap( &buflen ); |
|
IAllocBufferBlob_2( buflen ); |
|
if (buflen) |
|
s->Read( buflen,(void*)IGetBufferBlob_2() ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_1_Guid ) ) |
|
{ |
|
fBlob_1_Guid.Read( s ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_2_Guid ) ) |
|
{ |
|
fBlob_2_Guid.Read( s ); |
|
} |
|
} |
|
|
|
// NOTE: IF YOU CHANGE plVaultNode STREAM FORMAT, BE SURE TO |
|
// INCREMENT VaultNodeVersion (ABOVE). |
|
void plVaultNode::Write( hsStream * s, hsResMgr * mgr ) |
|
{ |
|
hsAssert( s, "nil stream" ); |
|
#ifdef HS_BUILD_FOR_UNIX |
|
plOperationTimer t( "plVaultNode::Write" ); |
|
t.Start( "write operation", 2 ); |
|
#endif |
|
|
|
|
|
fFieldFlags.Write( s ); |
|
|
|
// these fields are always streamed |
|
s->WriteSwap( fID ); |
|
s->WriteSwap( fType ); |
|
s->WriteSwap( fPermissions ); |
|
s->WriteSwap( fOwnerNodeID ); |
|
s->WriteSwap( fGroupNodeID ); |
|
fModifyTime.Write( s ); |
|
|
|
// fields relating to creation of this node |
|
if ( IIsFieldFlagSet( kCreatorNodeID ) ) |
|
{ |
|
s->WriteSwap( fCreatorNodeID ); |
|
} |
|
if ( IIsFieldFlagSet( kCreateTime ) ) |
|
{ |
|
fCreateTime.Write( s ); |
|
} |
|
// if ( IIsFieldFlagSet( kCreateAgeCoords ) ) |
|
// { |
|
// fCreateAgeCoords.Write( s, mgr ); |
|
// } |
|
if ( IIsFieldFlagSet( kCreateAgeTime ) ) |
|
{ |
|
fCreateAgeTime.Write( s ); |
|
} |
|
if ( IIsFieldFlagSet( kCreateAgeName ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fCreateAgeName, s ); |
|
} |
|
if ( IIsFieldFlagSet( kCreateAgeGuid ) ) |
|
{ |
|
fCreateAgeGuid.Write( s ); |
|
} |
|
// generic fields |
|
if ( IIsFieldFlagSet( kInt32_1 ) ) |
|
{ |
|
s->WriteSwap( fInt32_1 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_2 ) ) |
|
{ |
|
s->WriteSwap( fInt32_2 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_3 ) ) |
|
{ |
|
s->WriteSwap( fInt32_3 ); |
|
} |
|
if ( IIsFieldFlagSet( kInt32_4 ) ) |
|
{ |
|
s->WriteSwap( fInt32_4 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_1 ) ) |
|
{ |
|
s->WriteSwap( fUInt32_1 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_2 ) ) |
|
{ |
|
s->WriteSwap( fUInt32_2 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_3 ) ) |
|
{ |
|
s->WriteSwap( fUInt32_3 ); |
|
} |
|
if ( IIsFieldFlagSet( kUInt32_4 ) ) |
|
{ |
|
s->WriteSwap( fUInt32_4 ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_3 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_3, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_4 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_4, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_5 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_5, s ); |
|
} |
|
if ( IIsFieldFlagSet( kString64_6 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fString64_6, s ); |
|
} |
|
if ( IIsFieldFlagSet( kIString64_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fIString64_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kIString64_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fIString64_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kText_1 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fText_1, s ); |
|
} |
|
if ( IIsFieldFlagSet( kText_2 ) ) |
|
{ |
|
plMsgStdStringHelper::Poke( fText_2, s ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_1 ) ) |
|
{ |
|
UInt32 buflen = IGetBufferSizeBlob_1(); |
|
s->WriteSwap( buflen ); |
|
if ( buflen ) |
|
s->Write( buflen, IGetBufferBlob_1() ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_2 ) ) |
|
{ |
|
UInt32 buflen = IGetBufferSizeBlob_2(); |
|
s->WriteSwap( buflen ); |
|
if ( buflen ) |
|
s->Write( buflen, IGetBufferBlob_2() ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_1_Guid ) ) |
|
{ |
|
fBlob_1_Guid.Write( s ); |
|
} |
|
if ( IIsFieldFlagSet( kBlob_2_Guid ) ) |
|
{ |
|
fBlob_2_Guid.Write( s ); |
|
} |
|
} |
|
|
|
void plVaultNode::CopyFrom( const plVaultNode * other, bool forceCopyAllFields ) |
|
{ |
|
hsRAMStream ram; |
|
plVaultNode * nonConstOther = const_cast<plVaultNode*>( other ); |
|
|
|
hsBitVector saveFlags; |
|
if ( forceCopyAllFields ) |
|
{ |
|
saveFlags = nonConstOther->fFieldFlags; |
|
nonConstOther->ISetAllFieldFlags(); |
|
} |
|
|
|
nonConstOther->Write( &ram, nil ); |
|
ram.Rewind(); |
|
this->Read( &ram, nil ); |
|
|
|
if ( forceCopyAllFields ) |
|
{ |
|
nonConstOther->fFieldFlags = saveFlags; |
|
} |
|
} |
|
|
|
std::string plVaultNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%sNode[ID:%lu,Owner:%lu,Creator:%lu,Mod:%s]", |
|
space.c_str(), GetID(), GetOwnerNodeID(), GetCreatorNodeID(), |
|
fModifyTime.Format("%m/%d/%y %H:%M:%S GMT").c_str() ); |
|
return result; |
|
} |
|
|
|
std::string plVaultNode::FieldsAsStdString( void ) const |
|
{ |
|
std::stringstream stm; |
|
|
|
stm << "ID=" << GetID(); |
|
|
|
if ( IIsFieldFlagSet( plVaultNode::kPermissions ) ) |
|
{ |
|
stm << ", Permissions=" << GetPermissions(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kOwnerNodeID ) ) |
|
{ |
|
stm << ", OwnerIdx=" <<GetOwnerNodeID(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kGroupNodeID ) ) |
|
{ |
|
stm << ", GroupIdx=" << GetGroupNodeID(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kModifyTime ) ) |
|
{ |
|
stm << ", ModifyTime='" << GetModifyTime()->Format("%m/%d/%y %H:%M:%S").c_str() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kCreateAgeName ) ) |
|
{ |
|
stm << ", CreateAgeName='" << GetCreateAgeName() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kCreateAgeGuid ) ) |
|
{ |
|
stm << ", CreateAgeGuid='" << GetCreateAgeGuid()->AsStdString().c_str() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kInt32_1 ) ) |
|
{ |
|
stm << ", Int32_1=" << IGetInt32_1(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kInt32_2 ) ) |
|
{ |
|
stm << ", Int32_2=" << IGetInt32_2(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kInt32_3 ) ) |
|
{ |
|
stm << ", Int32_3=" << IGetInt32_3(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kUInt32_1 ) ) |
|
{ |
|
stm << ", UInt32_1=" << IGetUInt32_1(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kUInt32_2 ) ) |
|
{ |
|
stm << ", UInt32_2=" << IGetUInt32_2(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kUInt32_3 ) ) |
|
{ |
|
stm << ", UInt32_3=" << IGetUInt32_3(); |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_1 ) ) |
|
{ |
|
stm << ", String64_1='" << IGetString64_1() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_2 ) ) |
|
{ |
|
stm << ", String64_2='" << IGetString64_2() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_3 ) ) |
|
{ |
|
stm << ", String64_3='" << IGetString64_3() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_4 ) ) |
|
{ |
|
stm << ", String64_4='" << IGetString64_4() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_5 ) ) |
|
{ |
|
stm << ", String64_5='" << IGetString64_5() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kString64_6 ) ) |
|
{ |
|
stm << ", String64_6='" << IGetString64_6() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kIString64_1 ) ) |
|
{ |
|
stm << ", IString64_1='" << IGetIString64_1() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kIString64_2 ) ) |
|
{ |
|
stm << ", IString64_2='" << IGetIString64_2() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kText_1 ) ) |
|
{ |
|
stm << ", Text_1='" << IGetText_1() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kText_2 ) ) |
|
{ |
|
stm << ", Text_2='" << IGetText_2() << "'"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kBlob_1 ) ) |
|
{ |
|
stm << ", Blob_1"; |
|
} |
|
if ( IIsFieldFlagSet( plVaultNode::kBlob_2 ) ) |
|
{ |
|
stm << ", Blob_2"; |
|
} |
|
|
|
return stm.str(); |
|
} |
|
|
|
|
|
void plVaultNode::Dump( int level, bool displaySeen, bool beenSeen, plStatusLog * log ) const |
|
{ |
|
if (!fMyNodeMgr) |
|
return; |
|
if ( !log ) |
|
log = fMyNodeMgr->GetStatusLog(); |
|
std::string str; |
|
if ( displaySeen ) |
|
xtl::format( str, "%s, seen:%s", AsStdString( level ).c_str(), beenSeen?"yes":"no" ); |
|
else |
|
xtl::format( str, "%s", AsStdString( level ).c_str() ); |
|
hsLogEntry(log->AddLine( str.c_str() )); |
|
for ( plVault::NodeRefVec::const_iterator it=fChildNodes.begin(); it!=fChildNodes.end(); ++it ) |
|
{ |
|
plVaultNodeRef * nodeRef = *it; |
|
plVaultNode * node = nodeRef->GetChild(); |
|
if ( node ) |
|
node->Dump( level+2, true, nodeRef->BeenSeen() ); |
|
} |
|
} |
|
|
|
void plVaultNode::SetInitialized( bool b ) |
|
{ |
|
fInitialized = b; |
|
if (!fMyNodeMgr) |
|
return; |
|
if ( fInitialized ) |
|
fMyNodeMgr->INotifyNodeInitialized( this ); |
|
} |
|
|
|
bool plVaultNode::StartInitializing( plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
plVNodeInitTask * initTask = fMyNodeMgr ? fMyNodeMgr->IGetNodeInitializationTask( this ) : nil; |
|
if ( initTask ) |
|
{ |
|
initTask->SetCbObject( cb, cbContext ); |
|
initTask->Start(); |
|
return true; // initTask started |
|
} |
|
else |
|
{ |
|
SetInitialized( true ); |
|
plVaultOperationCallbackHolder cbHolder( fMyNodeMgr, cb, cbContext ); |
|
cbHolder.OperationComplete( hsOK ); |
|
return false; // no initTask started |
|
} |
|
} |
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultFolderNode::plVaultFolderNode() |
|
{ |
|
ISetType( plVault::kNodeType_Folder ); |
|
} |
|
|
|
plVaultFolderNode::~plVaultFolderNode() |
|
{ |
|
} |
|
|
|
std::string plVaultFolderNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Type:%s,Name:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), plVault::StandardNodeStr( GetFolderType() ), |
|
GetFolderName(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
std::string plVaultFolderNode::AsHtmlForm( const char * action ) |
|
{ |
|
std::stringstream ss; |
|
ss << "<form name='VaultNode' method='post' action='" << action << "'>" << std::endl; |
|
ss << "</form>" << std::endl; |
|
return ss.str(); |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultImageNode::plVaultImageNode() |
|
: fMipmap( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_Image ); |
|
} |
|
|
|
plVaultImageNode::~plVaultImageNode() |
|
{ |
|
} |
|
|
|
void plVaultImageNode::CopyFrom( const plVaultNode * other, bool forceCopyAllFields ) |
|
{ |
|
const plVaultImageNode * IMG = plVaultImageNode::ConvertNoRef( other ); |
|
if ( IMG ) |
|
fMipmap = IMG->fMipmap; |
|
plVaultNode::CopyFrom( other, forceCopyAllFields ); |
|
} |
|
|
|
std::string plVaultImageNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Size:%d] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), GetBufSize(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultTextNoteNode::plVaultTextNoteNode() |
|
{ |
|
ISetType( plVault::kNodeType_TextNote ); |
|
} |
|
|
|
plVaultTextNoteNode::~plVaultTextNoteNode() |
|
{ |
|
} |
|
|
|
void plVaultTextNoteNode::SetText( const char * text ) |
|
{ |
|
std::string work=text; memcpy( IAllocBufferBlob_1( work.size() ), work.c_str(), work.size() ); |
|
} |
|
|
|
std::string plVaultTextNoteNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Title:%s,Text:%s,Type:%d,Sub:%d] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), GetTitle(), |
|
GetText(), GetNoteType(), GetNoteSubType(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
plVaultFolderNode * plVaultTextNoteNode::GetDeviceInbox() const |
|
{ |
|
hsAssert( GetNoteType()==plVault::kNoteType_Device, "This text note is not a device." ); |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kDeviceInboxFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
return plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return nil; |
|
} |
|
|
|
void plVaultTextNoteNode::SetDeviceInbox( const char * inboxName, |
|
plVaultOperationCallback * cb/*=nil*/, UInt32 cbContext/*=0*/ ) |
|
{ |
|
// Remove old inbox. |
|
plVaultFolderNode * inbox = GetDeviceInbox(); |
|
if ( inbox ) |
|
RemoveNode( inbox->GetID() ); |
|
// Link to new inbox. |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kDeviceInboxFolder ); |
|
tmp.SetFolderName( inboxName ); |
|
// if the inbox name matches our device title, then |
|
// connect to our own personal version of the inbox, |
|
// else connect to the shared copy of the inbox. |
|
if ( stricmp( inboxName, GetTitle() )==0 ) |
|
tmp.SetOwnerNodeID( GetID() ); |
|
LinkToNode( &tmp, plVault::kFetchAllChildren, true, cb, cbContext ); |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultSDLNode::plVaultSDLNode() |
|
: fSDLDataRec( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_SDL ); |
|
} |
|
|
|
plVaultSDLNode::~plVaultSDLNode() |
|
{ |
|
delete fSDLDataRec; |
|
} |
|
|
|
void plVaultSDLNode::Save( |
|
plVaultOperationCallback * cb/*=nil*/, |
|
UInt32 cbContext/*=0 */) |
|
{ |
|
#ifdef HS_DEBUGGING |
|
hsLogEntry( DumpStateDataRecord("Saving plVaultSDLNode", false ) ); |
|
#endif |
|
plVaultNode::Save( cb, cbContext ); |
|
} |
|
|
|
plStateDataRecord * plVaultSDLNode::GetStateDataRecord( UInt32 readOptions/*=0 */) const |
|
{ |
|
delete fSDLDataRec; |
|
fSDLDataRec = nil; |
|
|
|
if ( GetBufSize()==0 || GetBuffer()==nil ) |
|
return nil; |
|
|
|
hsRAMStream ram; |
|
ram.Write( GetBufSize(), GetBuffer() ); |
|
ram.Rewind(); |
|
char * sdlRecName=nil; |
|
int sdlRecVersion; |
|
plStateDataRecord::ReadStreamHeader( &ram, &sdlRecName, &sdlRecVersion ); |
|
|
|
hsLogEntry(plSafeGetLog()->AddLineF( "SDLNode: SDL: name %s, version %d.", sdlRecName, sdlRecVersion )); |
|
|
|
plStateDescriptor* des = plSDLMgr::GetInstance()->FindDescriptor(sdlRecName, sdlRecVersion ); |
|
if (!des) |
|
{ |
|
hsLogEntry(plSafeGetLog()->AddLineF( "SDLNode: Can't find SDL desc, name:%s ver:%d. Attempting to read with latest descriptor.", sdlRecName, sdlRecVersion )); |
|
des = plSDLMgr::GetInstance()->FindDescriptor(sdlRecName, plSDL::kLatestVersion ); |
|
if (!des) |
|
{ |
|
hsLogEntry(plSafeGetLog()->AddLineF( "SDLNode: Can't find SDL desc, name:%s ver:kLatestVersion. Cannot read sdl record.", sdlRecName )); |
|
return nil; |
|
} |
|
} |
|
|
|
fSDLDataRec = TRACKED_NEW plStateDataRecord( des ); |
|
if ( !fSDLDataRec->Read( &ram, 0, readOptions ) ) |
|
{ |
|
hsLogEntry(plSafeGetLog()->AddLineF( "SDLNode: Failed to read SDL desc, name:%s ver:%d", sdlRecName, sdlRecVersion )); |
|
delete fSDLDataRec; |
|
fSDLDataRec = nil; |
|
} |
|
else |
|
{ |
|
hsLogEntry(plSafeGetLog()->AddLineF( "SDLNode: After reading SDL: name %s, version %d.", |
|
fSDLDataRec->GetDescriptor()->GetName(), fSDLDataRec->GetDescriptor()->GetVersion() )); |
|
} |
|
|
|
delete [] sdlRecName; |
|
return fSDLDataRec; |
|
} |
|
|
|
void plVaultSDLNode::InitStateDataRecord( const char * sdlRecName, UInt32 writeOptions/*=0 */) |
|
{ |
|
if ( !GetStateDataRecord() ) |
|
{ |
|
delete fSDLDataRec; |
|
fSDLDataRec = nil; |
|
|
|
plStateDescriptor* des = plSDLMgr::GetInstance()->FindDescriptor(sdlRecName, plSDL::kLatestVersion); |
|
if ( !des ) |
|
{ |
|
hsLogEntry( plSafeGetLog()->AddLineF( "SDLNode: Can't find SDL desc, name:%s", sdlRecName ) ); |
|
return; |
|
} |
|
|
|
fSDLDataRec = TRACKED_NEW plStateDataRecord( des ); |
|
fSDLDataRec->SetFromDefaults( false ); |
|
SetStateDataRecord( fSDLDataRec, writeOptions|plSDL::kDontWriteDirtyFlag ); |
|
Save(); |
|
} |
|
} |
|
|
|
|
|
void plVaultSDLNode::SetStateDataRecord( const plStateDataRecord * rec, UInt32 writeOptions/*=0 */) |
|
{ |
|
hsRAMStream ram; |
|
rec->WriteStreamHeader( &ram ); |
|
rec->Write( &ram, 0, writeOptions ); |
|
ram.Rewind(); |
|
ram.CopyToMem( AllocBuffer( ram.GetEOF() ) ); |
|
} |
|
|
|
void plVaultSDLNode::DumpStateDataRecord( const char * msg/*=nil */, bool dirtyOnly/*=false*/ ) const |
|
{ |
|
if ( !fSDLDataRec ) |
|
GetStateDataRecord(); |
|
|
|
if ( !fSDLDataRec ) |
|
return; |
|
|
|
if ( !msg ) |
|
msg = "VaultSDLNode"; |
|
|
|
fSDLDataRec->DumpToObjectDebugger( msg, dirtyOnly ); |
|
} |
|
|
|
std::string plVaultSDLNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Size:%d,Ident:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetBufSize(), plVault::StandardNodeStr( GetIdent() ), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultAgeInfoNode::plVaultAgeInfoNode() |
|
: fCanVisitFolder( nil ) |
|
, fAgeOwnersFolder( nil ) |
|
, fChildAgesFolder( nil ) |
|
, fAgeSDL( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_AgeInfo ); |
|
} |
|
|
|
plVaultAgeInfoNode::~plVaultAgeInfoNode() |
|
{ |
|
} |
|
|
|
plVaultAgeLinkNode * plVaultAgeInfoNode::IGetLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const |
|
{ |
|
plVaultNodeIterator it = folder->GetIterator(); |
|
|
|
for ( it; it; ++it ) |
|
{ |
|
plVaultAgeLinkNode * linkNode = plVaultAgeLinkNode::ConvertNoRef( it->GetChild() ); |
|
if ( !linkNode ) |
|
continue; |
|
plVaultAgeInfoNode * infoNode = linkNode->GetAgeInfo(); |
|
if ( !infoNode ) |
|
continue; |
|
if ( info->HasAgeInstanceGuid() && infoNode->GetAgeInstanceGuid()->IsEqualTo( info->GetAgeInstanceGuid() ) ) |
|
return linkNode; |
|
if ( info->HasAgeInstanceName() && stricmp( infoNode->GetAgeInstanceName(), info->GetAgeInstanceName() )==0 ) |
|
return linkNode; |
|
if ( info->HasAgeFilename() && stricmp( infoNode->GetAgeFilename(), info->GetAgeFilename() )==0 ) |
|
return linkNode; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
const plNetServerSessionInfo * plVaultAgeInfoNode::AsServerInfo() const |
|
{ |
|
fServerInfo.Clear(); |
|
fServerInfo.SetServerName( GetAgeInstanceName() ); |
|
fServerInfo.SetServerGuid( GetAgeInstanceGuid() ); |
|
return &fServerInfo; |
|
} |
|
|
|
const plAgeInfoStruct * plVaultAgeInfoNode::AsAgeInfoStruct() const |
|
{ |
|
fAgeInfoStruct.SetAgeFilename( GetAgeFilename() ); |
|
fAgeInfoStruct.SetAgeInstanceName( GetAgeInstanceName() ); |
|
fAgeInfoStruct.SetAgeInstanceGuid( GetAgeInstanceGuid() ); |
|
fAgeInfoStruct.SetAgeUserDefinedName( GetAgeUserDefinedName() ); |
|
fAgeInfoStruct.SetAgeSequenceNumber( GetSequenceNumber() ); |
|
fAgeInfoStruct.SetAgeDescription( GetAgeDescription() ); |
|
return &fAgeInfoStruct; |
|
} |
|
|
|
|
|
void plVaultAgeInfoNode::FromAgeInfoStruct( const plAgeInfoStruct * ageInfo ) |
|
{ |
|
if ( ageInfo->HasAgeFilename() ) |
|
SetAgeFilename( ageInfo->GetAgeFilename() ); |
|
if ( ageInfo->HasAgeInstanceName() ) |
|
SetAgeInstanceName( ageInfo->GetAgeInstanceName() ); |
|
if ( ageInfo->HasAgeInstanceGuid() ) |
|
SetAgeInstanceGuid( ageInfo->GetAgeInstanceGuid() ); |
|
if ( ageInfo->HasAgeUserDefinedName() ) |
|
SetAgeUserDefinedName( ageInfo->GetAgeUserDefinedName() ); |
|
if ( ageInfo->HasAgeSequenceNumber() ) |
|
SetSequenceNumber( ageInfo->GetAgeSequenceNumber() ); |
|
if ( ageInfo->HasAgeDescription() ) |
|
SetAgeDescription( ageInfo->GetAgeDescription() ); |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultAgeInfoNode::GetCanVisitFolder( void ) const |
|
{ |
|
if ( fCanVisitFolder ) |
|
return fCanVisitFolder; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kCanVisitFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fCanVisitFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fCanVisitFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fCanVisitFolder node not found" )); |
|
return fCanVisitFolder; |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultAgeInfoNode::GetAgeOwnersFolder( void ) const |
|
{ |
|
if ( fAgeOwnersFolder ) |
|
return fAgeOwnersFolder; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kAgeOwnersFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeOwnersFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgeOwnersFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgeOwnersFolder node not found" )); |
|
return fAgeOwnersFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeInfoNode::GetChildAgesFolder( void ) const |
|
{ |
|
if ( fChildAgesFolder ) |
|
return fChildAgesFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kChildAgesFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fChildAgesFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fChildAgesFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fChildAgesFolder node not found" )); |
|
return fChildAgesFolder; |
|
} |
|
|
|
plVaultAgeLinkNode * plVaultAgeInfoNode::GetChildAgeLink( const plAgeInfoStruct * info ) const |
|
{ |
|
GetChildAgesFolder(); |
|
hsAssert( fChildAgesFolder, "Missing ChildAges folder" ); |
|
if (fChildAgesFolder) |
|
return IGetLink( fChildAgesFolder, info ); |
|
return nil; |
|
} |
|
|
|
plVaultSDLNode * plVaultAgeInfoNode::IGetAgeSDL() const |
|
{ |
|
if ( fAgeSDL ) |
|
return fAgeSDL; |
|
plVaultSDLNode tmp; |
|
tmp.SetIdent( plVault::kAgeInstanceSDLNode ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeSDL = plVaultSDLNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgeSDL ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgeSDL node not found" )); |
|
return fAgeSDL; |
|
} |
|
|
|
plVaultPlayerInfoNode * plVaultAgeInfoNode::GetCzar() const |
|
{ |
|
if ( !GetAgeOwnersFolder() ) |
|
return nil; |
|
GetAgeOwnersFolder()->Sort(); |
|
plVaultNodeIterator it = GetAgeOwnersFolder()->GetIterator(); |
|
if ( it.GetCount()==0 ) |
|
return nil; |
|
return plVaultPlayerInfoNode::ConvertNoRef( it.GetAt( 0 )->GetChild() ); |
|
} |
|
|
|
|
|
const char * plVaultAgeInfoNode::GetDisplayName() const |
|
{ |
|
return AsAgeInfoStruct()->GetDisplayName(); |
|
} |
|
|
|
std::string plVaultAgeInfoNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Age:%lu,FName:%s,IName:%s,Guid:%s,UName:%s,Seq:%d,Pub:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetAgeID(), GetAgeFilename(), GetAgeInstanceName(), |
|
GetAgeInstanceGuid()->AsStdString().c_str(), GetAgeUserDefinedName(), |
|
GetSequenceNumber(), IsPublic()?"yes":"no", plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultAgeLinkNode::plVaultAgeLinkNode() |
|
: fAgeInfo( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_AgeLink ); |
|
} |
|
|
|
plVaultAgeLinkNode::~plVaultAgeLinkNode() |
|
{ |
|
} |
|
|
|
plVaultAgeInfoNode * plVaultAgeLinkNode::GetAgeInfo() const |
|
{ |
|
if ( fAgeInfo ) |
|
return fAgeInfo; |
|
plVaultAgeInfoNode tmp; |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeInfo = plVaultAgeInfoNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return fAgeInfo; |
|
} |
|
|
|
void plVaultAgeLinkNode::SetAgeInfo( plVaultAgeInfoNode * node ) |
|
{ |
|
plVaultAgeInfoNode * curr = GetAgeInfo(); |
|
if ( curr ) |
|
{ |
|
if ( curr->GetID()==node->GetID() ) |
|
return; |
|
|
|
RemoveNode( curr->GetID() ); |
|
} |
|
fAgeInfo = nil; |
|
AddNode( node ); |
|
} |
|
|
|
struct MatchesSpawnPointTitle |
|
{ |
|
std::string fTitle; |
|
MatchesSpawnPointTitle( const char * title ):fTitle( title ){} |
|
bool operator ()( const plSpawnPointInfo & p ) const { return ( p.fTitle==fTitle ); } |
|
}; |
|
struct MatchesSpawnPointName |
|
{ |
|
std::string fName; |
|
MatchesSpawnPointName( const char * name ):fName( name ){} |
|
bool operator ()( const plSpawnPointInfo & p ) const { return ( p.fSpawnPt==fName ); } |
|
}; |
|
|
|
void plVaultAgeLinkNode::AddSpawnPoint( const plSpawnPointInfo & point ) |
|
{ |
|
plSpawnPointVec points; |
|
GetSpawnPoints( points ); |
|
if ( std::find_if( points.begin(), points.end(), MatchesSpawnPointTitle( point.fTitle.c_str() ) )!=points.end() ) |
|
return; |
|
|
|
// only check to see if the titles are the same... |
|
//... so we can add the same spawnpoint as long as they have different titles |
|
//if ( std::find_if( points.begin(), points.end(), MatchesSpawnPointName( point.fSpawnPt.c_str() ) )!=points.end() ) |
|
// return; |
|
|
|
points.push_back( point ); |
|
SetSpawnPoints( points ); |
|
} |
|
|
|
void plVaultAgeLinkNode::RemoveSpawnPoint( const char * spawnPtName ) |
|
{ |
|
plSpawnPointVec points; |
|
GetSpawnPoints( points ); |
|
plSpawnPointVec::iterator it = std::find_if( points.begin(), points.end(), MatchesSpawnPointName( spawnPtName ) ); |
|
if ( it!=points.end() ) |
|
{ |
|
points.erase( it ); |
|
SetSpawnPoints( points ); |
|
} |
|
} |
|
|
|
bool plVaultAgeLinkNode::HasSpawnPoint( const plSpawnPointInfo & point ) const |
|
{ |
|
return HasSpawnPoint( point.GetName() ); |
|
} |
|
|
|
bool plVaultAgeLinkNode::HasSpawnPoint( const char * spawnPtName ) const |
|
{ |
|
plSpawnPointVec points; |
|
GetSpawnPoints( points ); |
|
return ( std::find_if( points.begin(), points.end(), MatchesSpawnPointName( spawnPtName ) )!=points.end() ); |
|
} |
|
|
|
void plVaultAgeLinkNode::GetSpawnPoints( plSpawnPointVec & out ) const |
|
{ |
|
char token1[ 1024 ]; |
|
hsStringTokenizer izer1( (const char *)IGetBufferBlob_1(), ";" ); |
|
while ( izer1.Next( token1, sizeof( token1 ) ) ) |
|
{ |
|
plSpawnPointInfo point; |
|
char token2[ 1024 ]; |
|
hsStringTokenizer izer2( token1, ":" ); |
|
if ( izer2.Next( token2, sizeof( token2 ) ) ) |
|
point.fTitle = token2; |
|
if ( izer2.Next( token2, sizeof( token2 ) ) ) |
|
point.fSpawnPt = token2; |
|
if ( izer2.Next( token2, sizeof( token2 ) ) ) |
|
point.fCameraStack = token2; |
|
out.push_back( point ); |
|
} |
|
} |
|
|
|
void plVaultAgeLinkNode::SetSpawnPoints( const plSpawnPointVec & in ) |
|
{ |
|
std::stringstream ss; |
|
for ( int i=0; i<in.size(); i++ ) |
|
ss |
|
<< in[i].fTitle << ":" |
|
<< in[i].fSpawnPt << ":" |
|
<< in[i].fCameraStack << ";" |
|
; |
|
char * buf = (char *)IAllocBufferBlob_1( ss.str().size() ); |
|
strcpy( buf, ss.str().c_str() ); |
|
} |
|
|
|
std::string plVaultAgeLinkNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
const char * spawnPts = (const char *)IGetBufferBlob_1(); |
|
xtl::format( result, "%s%s[Locked:%d Volatile:%d,SpnPts:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetLocked(), GetVolatile(), spawnPts?spawnPts:"(nil)", |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultChronicleNode::plVaultChronicleNode() |
|
{ |
|
ISetType( plVault::kNodeType_Chronicle ); |
|
} |
|
|
|
plVaultChronicleNode::~plVaultChronicleNode() |
|
{ |
|
} |
|
|
|
std::string plVaultChronicleNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Name:%s,Type:%lu,Value:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), GetName(), |
|
GetEntryType(), GetValue(), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultPlayerInfoNode::plVaultPlayerInfoNode() |
|
{ |
|
ISetType( plVault::kNodeType_PlayerInfo ); |
|
} |
|
|
|
plVaultPlayerInfoNode::~plVaultPlayerInfoNode() |
|
{ |
|
} |
|
|
|
void plVaultPlayerInfoNode::SetPlayerName( const char * text ) |
|
{ |
|
if ( fMyNodeMgr ) |
|
CheckIAmSuperUserOr_VoidReturn( fMyNodeMgr, ( !IsStored()||fMyNodeMgr->IIsThisMe( this ) ) ); |
|
ISetIString64_1( text ); |
|
} |
|
|
|
void plVaultPlayerInfoNode::SetPlayerID( UInt32 v ) |
|
{ |
|
if ( fMyNodeMgr ) |
|
CheckIAmSuperUserOr_VoidReturn( fMyNodeMgr, ( !IsStored()||fMyNodeMgr->IIsThisMe( this ) ) ); |
|
ISetUInt32_1( v ); |
|
} |
|
|
|
void plVaultPlayerInfoNode::SetAgeInstanceName( const char * v ) |
|
{ |
|
ISetString64_1( v ); |
|
} |
|
|
|
const char * plVaultPlayerInfoNode::GetAgeInstanceName( void ) const |
|
{ |
|
return ( IsOnline() ) ? IGetString64_1() : ""; |
|
} |
|
|
|
void plVaultPlayerInfoNode::SetAgeGuid( const plUUID * v) |
|
{ |
|
ISetString64_2( v->AsStdString().c_str() ); |
|
} |
|
|
|
const plUUID * plVaultPlayerInfoNode::GetAgeGuid( void ) const |
|
{ |
|
if ( IsOnline() ) |
|
fGuid.FromString( IGetString64_2() ); |
|
else |
|
fGuid.Clear(); |
|
return &fGuid; |
|
} |
|
|
|
void plVaultPlayerInfoNode::SetOnline( bool b ) |
|
{ |
|
ISetInt32_1( b ); |
|
} |
|
|
|
|
|
std::string plVaultPlayerInfoNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[PlayerID:%lu,PlayerName:%s,IsOnline:%s,InAge:%s,InAgeGuid:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), GetPlayerID(), |
|
GetPlayerName(), (IsOnline())?"yes":"no", |
|
GetAgeInstanceName(), GetAgeGuid()->AsStdString().c_str(), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
// true if A is less than B |
|
bool PlayerInfoNodeCompare( const plVaultNode * a, const plVaultNode * b ) |
|
{ |
|
const plVaultPlayerInfoNode * A = plVaultPlayerInfoNode::ConvertNoRef( a ); |
|
const plVaultPlayerInfoNode * B = plVaultPlayerInfoNode::ConvertNoRef( b ); |
|
|
|
if ( !A ) |
|
return false; |
|
if ( !B ) |
|
return true; |
|
if ( A->IsOnline() && !B->IsOnline() ) |
|
return true; |
|
if ( B->IsOnline() && !A->IsOnline() ) |
|
return false; |
|
return ( stricmp( A->GetPlayerName(), B->GetPlayerName() )<0 ); |
|
} |
|
|
|
bool PlayerInfoNodeRefCompare( const plVaultNodeRef * nodeRefA, const plVaultNodeRef * nodeRefB ) |
|
{ |
|
if ( !nodeRefA || !nodeRefB ) |
|
return false; |
|
|
|
return PlayerInfoNodeCompare( nodeRefA->GetChild(), nodeRefB->GetChild() ); |
|
}; |
|
|
|
plVaultPlayerInfoListNode::plVaultPlayerInfoListNode() |
|
{ |
|
ISetType( plVault::kNodeType_PlayerInfoList ); |
|
} |
|
|
|
plVaultPlayerInfoListNode::~plVaultPlayerInfoListNode() |
|
{ |
|
} |
|
|
|
bool plVaultPlayerInfoListNode::HasPlayer( UInt32 playerID ) |
|
{ |
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( playerID ); |
|
plVaultNodeRef * tmp; |
|
return FindNode( &templateNode, tmp ); |
|
} |
|
|
|
bool plVaultPlayerInfoListNode::AddPlayer( UInt32 playerID ) |
|
{ |
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( playerID ); |
|
plVaultNodeRef * tmp; |
|
if ( !FindNode( &templateNode, tmp ) ) |
|
return LinkToNode( &templateNode ); |
|
return true; |
|
} |
|
|
|
void plVaultPlayerInfoListNode::RemovePlayer( UInt32 playerID ) |
|
{ |
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( playerID ); |
|
plVaultNodeRef * tmp; |
|
if ( FindNode( &templateNode, tmp ) ) |
|
RemoveNode( tmp->GetChildID() ); |
|
} |
|
|
|
plVaultPlayerInfoNode * plVaultPlayerInfoListNode::GetPlayer( UInt32 playerID ) |
|
{ |
|
plVaultPlayerInfoNode templateNode; |
|
templateNode.SetPlayerID( playerID ); |
|
plVaultNodeRef * tmp; |
|
if ( FindNode( &templateNode, tmp ) ) |
|
return plVaultPlayerInfoNode::ConvertNoRef( tmp->GetChild() ); |
|
return nil; |
|
} |
|
|
|
|
|
void plVaultPlayerInfoListNode::SetPlayers( const plVault::IDVec & playerIDs ) |
|
{ |
|
RemoveAllNodes(); |
|
for ( int i=0; i<playerIDs.size(); i++ ) |
|
AddPlayer( playerIDs[i] ); |
|
} |
|
|
|
void plVaultPlayerInfoListNode::ISortPlayers( plNodeRefCompareProc compare ) |
|
{ |
|
std::sort( fChildNodes.begin(), fChildNodes.end(), compare ); |
|
} |
|
|
|
void plVaultPlayerInfoListNode::Sort() |
|
{ |
|
ISortPlayers( PlayerInfoNodeRefCompare ); |
|
} |
|
|
|
void plVaultPlayerInfoListNode::ILocalNodeAdded( plVaultNodeRef * nodeRef ) |
|
{ |
|
Sort(); |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultAgeInfoListNode::plVaultAgeInfoListNode() |
|
{ |
|
ISetType( plVault::kNodeType_AgeInfoList ); |
|
} |
|
|
|
plVaultAgeInfoListNode::~plVaultAgeInfoListNode() |
|
{ |
|
} |
|
|
|
bool plVaultAgeInfoListNode::HasAge( UInt32 ageID ) |
|
{ |
|
plVaultAgeInfoNode templateNode; |
|
templateNode.SetAgeID( ageID ); |
|
plVaultNodeRef * tmp; |
|
return FindNode( &templateNode, tmp ); |
|
} |
|
|
|
bool plVaultAgeInfoListNode::AddAge( UInt32 ageID ) |
|
{ |
|
plVaultAgeInfoNode templateNode; |
|
templateNode.SetAgeID( ageID ); |
|
plVaultNodeRef * tmp; |
|
if ( !FindNode( &templateNode, tmp ) ) |
|
return LinkToNode( &templateNode ); |
|
return true; |
|
} |
|
|
|
void plVaultAgeInfoListNode::RemoveAge( UInt32 ageID ) |
|
{ |
|
plVaultAgeInfoNode templateNode; |
|
templateNode.SetAgeID( ageID ); |
|
plVaultNodeRef * tmp; |
|
if ( FindNode( &templateNode, tmp ) ) |
|
RemoveNode( tmp->GetChildID() ); |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
plVaultMgrNode::plVaultMgrNode() |
|
: fMyInboxFolder( nil ), fSystemNode(nil) |
|
{ |
|
} |
|
|
|
plVaultMgrNode::~plVaultMgrNode() |
|
{ |
|
} |
|
|
|
plVaultFolderNode * plVaultMgrNode::GetInbox( void ) const |
|
{ |
|
if ( fMyInboxFolder ) |
|
return fMyInboxFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kInboxFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fMyInboxFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return fMyInboxFolder; |
|
} |
|
|
|
plVaultSystemNode * plVaultMgrNode::GetSystemNode( ) const |
|
{ |
|
if ( fSystemNode ) |
|
return fSystemNode; |
|
plVaultSystemNode tmp; |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fSystemNode = plVaultSystemNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return fSystemNode; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultPlayerNode::plVaultPlayerNode() |
|
: fPlayerInfo( nil ) |
|
, fAvatarOutfitFolder( nil ) |
|
, fAvatarClosetFolder( nil ) |
|
, fChronicleFolder( nil ) |
|
, fIgnoreListFolder( nil ) |
|
, fBuddyListFolder( nil ) |
|
, fPeopleIKnowAboutFolder( nil ) |
|
, fAgeJournalsFolder( nil ) |
|
, fAgesICanVisitFolder( nil ) |
|
, fAgesIOwnFolder( nil ) |
|
, fInviteFolder( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_VNodeMgrPlayer ); |
|
} |
|
|
|
plVaultPlayerNode::~plVaultPlayerNode() |
|
{ |
|
} |
|
|
|
plVaultPlayerInfoNode * plVaultPlayerNode::GetPlayerInfo() const |
|
{ |
|
static plVaultPlayerInfoNode s_nilNode; |
|
if ( fPlayerInfo && fPlayerInfo != &s_nilNode) |
|
return fPlayerInfo; |
|
fPlayerInfo = nil; |
|
plVaultPlayerInfoNode tmp; |
|
tmp.SetPlayerID( GetID() ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fPlayerInfo = plVaultPlayerInfoNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if (!fPlayerInfo) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fPlayerInfo node not found" )); |
|
fPlayerInfo = &s_nilNode; |
|
} |
|
return fPlayerInfo; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetAvatarOutfitFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAvatarOutfitFolder && fAvatarOutfitFolder != &s_nilNode) |
|
return fAvatarOutfitFolder; |
|
fAvatarOutfitFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAvatarOutfitFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAvatarOutfitFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAvatarOutfitFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAvatarOutfitFolder node not found" )); |
|
fAvatarOutfitFolder = &s_nilNode; |
|
} |
|
return fAvatarOutfitFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetAvatarClosetFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAvatarClosetFolder && fAvatarClosetFolder != &s_nilNode) |
|
return fAvatarClosetFolder; |
|
fAvatarClosetFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAvatarClosetFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAvatarClosetFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAvatarClosetFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAvatarClosetFolder node not found" )); |
|
fAvatarClosetFolder = &s_nilNode; |
|
} |
|
return fAvatarClosetFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetChronicleFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fChronicleFolder && fChronicleFolder != &s_nilNode) |
|
return fChronicleFolder; |
|
fChronicleFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kChronicleFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fChronicleFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fChronicleFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fChronicleFolder node not found" )); |
|
fChronicleFolder = &s_nilNode; |
|
} |
|
return fChronicleFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetAgeJournalsFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAgeJournalsFolder && fAgeJournalsFolder != &s_nilNode) |
|
return fAgeJournalsFolder; |
|
fAgeJournalsFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAgeJournalsFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeJournalsFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgeJournalsFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgeJournalsFolder node not found" )); |
|
fAgeJournalsFolder = &s_nilNode; |
|
} |
|
return fAgeJournalsFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetAgesICanVisitFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAgesICanVisitFolder && fAgesICanVisitFolder != &s_nilNode) |
|
return fAgesICanVisitFolder; |
|
fAgesICanVisitFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAgesICanVisitFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgesICanVisitFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgesICanVisitFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgesICanVisitFolder node not found" )); |
|
fAgesICanVisitFolder = &s_nilNode; |
|
} |
|
return fAgesICanVisitFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetAgesIOwnFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAgesIOwnFolder && fAgesIOwnFolder != &s_nilNode) |
|
return fAgesIOwnFolder; |
|
fAgesIOwnFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAgesIOwnFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgesIOwnFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgesIOwnFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgesIOwnFolder node not found" )); |
|
fAgesIOwnFolder = &s_nilNode; |
|
} |
|
return fAgesIOwnFolder; |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultPlayerNode::GetIgnoreListFolder( void ) const |
|
{ |
|
static plVaultPlayerInfoListNode s_nilNode; |
|
if ( fIgnoreListFolder && fIgnoreListFolder != &s_nilNode) |
|
return fIgnoreListFolder; |
|
fIgnoreListFolder = nil; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kIgnoreListFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fIgnoreListFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fIgnoreListFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fIgnoreListFolder node not found" )); |
|
fIgnoreListFolder = &s_nilNode; |
|
} |
|
return fIgnoreListFolder; |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultPlayerNode::GetBuddyListFolder( void ) const |
|
{ |
|
static plVaultPlayerInfoListNode s_nilNode; |
|
if ( fBuddyListFolder && fBuddyListFolder != &s_nilNode) |
|
return fBuddyListFolder; |
|
fBuddyListFolder = nil; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kBuddyListFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fBuddyListFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fBuddyListFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fBuddyListFolder node not found" )); |
|
fBuddyListFolder = &s_nilNode; |
|
} |
|
return fBuddyListFolder; |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultPlayerNode::GetPeopleIKnowAboutFolder( void ) const |
|
{ |
|
static plVaultPlayerInfoListNode s_nilNode; |
|
if ( fPeopleIKnowAboutFolder && fPeopleIKnowAboutFolder != &s_nilNode) |
|
return fPeopleIKnowAboutFolder; |
|
fPeopleIKnowAboutFolder = nil; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kPeopleIKnowAboutFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fPeopleIKnowAboutFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fPeopleIKnowAboutFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fPeopleIKnowAboutFolder node not found" )); |
|
fPeopleIKnowAboutFolder = &s_nilNode; |
|
} |
|
return fPeopleIKnowAboutFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultPlayerNode::GetInviteFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fInviteFolder && fInviteFolder != &s_nilNode) |
|
return fInviteFolder; |
|
fInviteFolder = nil; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kPlayerInviteFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fInviteFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fInviteFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fInviteFolder node not found" )); |
|
fInviteFolder = &s_nilNode; |
|
} |
|
return fInviteFolder; |
|
} |
|
|
|
////// |
|
|
|
plVaultAgeLinkNode * plVaultPlayerNode::GetLinkToMyNeighborhood() const |
|
{ |
|
plAgeInfoStruct info; |
|
info.SetAgeFilename( kNeighborhoodAgeFilename ); |
|
return GetOwnedAgeLink( &info ); |
|
} |
|
|
|
|
|
plVaultAgeLinkNode * plVaultPlayerNode::GetLinkToCity() const |
|
{ |
|
plAgeInfoStruct info; |
|
info.SetAgeFilename( kCityAgeFilename ); |
|
return GetOwnedAgeLink( &info ); |
|
} |
|
|
|
////// |
|
|
|
plVaultAgeLinkNode * plVaultPlayerNode::IFindLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const |
|
{ |
|
plVaultNodeIterator it = folder->GetIterator(); |
|
|
|
for ( it; it; ++it ) |
|
{ |
|
plVaultAgeLinkNode * linkNode = plVaultAgeLinkNode::ConvertNoRef( it->GetChild() ); |
|
if ( !linkNode ) |
|
continue; |
|
plVaultAgeInfoNode * infoNode = linkNode->GetAgeInfo(); |
|
if ( !infoNode ) |
|
continue; |
|
if ( info->IsEqualTo( infoNode->AsAgeInfoStruct() ) ) |
|
return linkNode; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
void plVaultPlayerNode::IRemoveLink( plVaultFolderNode * folder, const plUUID * guid ) |
|
{ |
|
plVaultNodeIterator it = folder->GetIterator(); |
|
|
|
for ( it; it; ++it ) |
|
{ |
|
plVaultAgeLinkNode * linkNode = plVaultAgeLinkNode::ConvertNoRef( it->GetChild() ); |
|
if ( !linkNode ) |
|
continue; |
|
plVaultAgeInfoNode * infoNode = linkNode->GetAgeInfo(); |
|
if ( !infoNode ) |
|
continue; |
|
if ( infoNode->GetAgeInstanceGuid()->IsEqualTo( guid ) ) |
|
{ |
|
folder->RemoveNode( linkNode->GetID() ); |
|
} |
|
} |
|
} |
|
|
|
/////////// |
|
|
|
plVaultAgeLinkNode * plVaultPlayerNode::GetOwnedAgeLink( const plAgeInfoStruct * info, bool skipVolatile/*=false */) const |
|
{ |
|
GetAgesIOwnFolder(); |
|
hsAssert( fAgesIOwnFolder, "Missing AgesIOwn folder" ); |
|
plAgeInfoStruct tmp; |
|
if ( info->HasAgeFilename() ) |
|
tmp.SetAgeFilename( info->GetAgeFilename() ); |
|
else if ( info->HasAgeInstanceGuid() ) |
|
tmp.SetAgeInstanceGuid( info->GetAgeInstanceGuid() ); |
|
else |
|
tmp.CopyFrom( info ); |
|
plVaultAgeLinkNode * result = IFindLink( fAgesIOwnFolder, &tmp ); |
|
|
|
if ( result && result->GetVolatile() && skipVolatile ) |
|
return nil; |
|
|
|
return result; |
|
} |
|
|
|
|
|
void plVaultPlayerNode::RemoveOwnedAgeLink( const plUUID * guid ) |
|
{ |
|
GetAgesIOwnFolder(); |
|
hsAssert( fAgesIOwnFolder, "Missing AgesIOwn folder" ); |
|
IRemoveLink( fAgesIOwnFolder, guid ); |
|
} |
|
|
|
/////////// |
|
|
|
plVaultAgeLinkNode * plVaultPlayerNode::GetVisitAgeLink( const plAgeInfoStruct * info ) const |
|
{ |
|
GetAgesICanVisitFolder(); |
|
hsAssert( fAgesICanVisitFolder, "Missing AgesICanVisit folder" ); |
|
plAgeInfoStruct tmp; |
|
if ( info->HasAgeInstanceGuid() ) |
|
tmp.SetAgeInstanceGuid( info->GetAgeInstanceGuid() ); |
|
else |
|
tmp.CopyFrom( info ); |
|
return IFindLink( fAgesICanVisitFolder, &tmp ); |
|
} |
|
|
|
void plVaultPlayerNode::RemoveVisitAgeLink( const plUUID * guid ) |
|
{ |
|
GetAgesICanVisitFolder(); |
|
hsAssert( fAgesICanVisitFolder, "Missing AgesICanVisit folder" ); |
|
IRemoveLink( fAgesICanVisitFolder, guid ); |
|
} |
|
|
|
/////////// |
|
|
|
plVaultChronicleNode * plVaultPlayerNode::FindChronicleEntry( const char * entryName ) |
|
{ |
|
GetChronicleFolder(); |
|
hsAssert( fChronicleFolder, "Missing Chronicle folder" ); |
|
plVaultChronicleNode templateNode; |
|
templateNode.SetName( entryName ); |
|
plVaultNodeRef * tmp; |
|
if ( fChronicleFolder->FindNode( &templateNode, tmp ) ) |
|
return plVaultChronicleNode::ConvertNoRef( tmp->GetChild() ); |
|
return nil; |
|
} |
|
|
|
|
|
/////////// |
|
|
|
void plVaultPlayerNode::SetAccountUUID( const plUUID * v ) |
|
{ |
|
if ( fMyNodeMgr ) |
|
CheckIAmSuperUserOr_VoidReturn( fMyNodeMgr, ( !IsStored()||fMyNodeMgr->IIsThisMe( this ) ) ); |
|
fAcctUUID.CopyFrom( v ); |
|
ISetIString64_2( fAcctUUID.AsStdString().c_str() ); |
|
} |
|
|
|
const plUUID * plVaultPlayerNode::GetAccountUUID( void ) const |
|
{ |
|
if ( fAcctUUID.IsNull() ) |
|
fAcctUUID.FromString( IGetIString64_2() ); |
|
return &fAcctUUID; |
|
} |
|
|
|
void plVaultPlayerNode::SetPlayerName( const char * v ) |
|
{ |
|
if ( fMyNodeMgr ) |
|
CheckIAmSuperUserOr_VoidReturn( fMyNodeMgr, ( !IsStored()||fMyNodeMgr->IIsThisMe( this ) ) ); |
|
ISetIString64_1( v ); |
|
plVaultPlayerInfoNode * playerInfo = GetPlayerInfo(); |
|
if ( playerInfo ) |
|
playerInfo->SetPlayerName( v ); |
|
} |
|
|
|
void plVaultPlayerNode::SetAvatarShapeName( const char * v ) |
|
{ |
|
if ( fMyNodeMgr ) |
|
CheckIAmSuperUserOr_VoidReturn( fMyNodeMgr, ( !IsStored()||fMyNodeMgr->IIsThisMe( this ) ) ); |
|
ISetString64_1( v ); |
|
} |
|
|
|
void plVaultPlayerNode::Save( plVaultOperationCallback * cb, UInt32 cbContext ) |
|
{ |
|
if ( GetPlayerInfo() ) |
|
GetPlayerInfo()->Save(); |
|
plVaultNode::Save( cb, cbContext ); |
|
} |
|
|
|
|
|
std::string plVaultPlayerNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[ID:%lu,Nam:%s,Av:%s:Acct:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), GetID(), |
|
GetPlayerName(), GetAvatarShapeName(), GetAccountUUID()->AsStdString().c_str(), |
|
plVaultMgrNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultAgeNode::plVaultAgeNode() |
|
: fAgeInfo( nil ) |
|
, fAgesIOwnFolder( nil ) |
|
, fAgeDevicesFolder( nil ) |
|
, fSubAgesFolder( nil ) |
|
, fPeopleIKnowAboutFolder( nil ) |
|
, fPublicAgesFolder( nil ) |
|
, fChronicleFolder( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_VNodeMgrAge ); |
|
} |
|
|
|
plVaultAgeNode::~plVaultAgeNode() |
|
{ |
|
} |
|
|
|
plVaultAgeLinkNode * plVaultAgeNode::IGetLink( plVaultFolderNode * folder, const plAgeInfoStruct * info ) const |
|
{ |
|
plVaultNodeIterator it = folder->GetIterator(); |
|
|
|
for ( it; it; ++it ) |
|
{ |
|
plVaultAgeLinkNode * linkNode = plVaultAgeLinkNode::ConvertNoRef( it->GetChild() ); |
|
if ( !linkNode ) |
|
continue; |
|
plVaultAgeInfoNode * infoNode = linkNode->GetAgeInfo(); |
|
if ( !infoNode ) |
|
continue; |
|
if ( info->HasAgeInstanceGuid() && infoNode->GetAgeInstanceGuid()->IsEqualTo( info->GetAgeInstanceGuid() ) ) |
|
return linkNode; |
|
if ( info->HasAgeInstanceName() && stricmp( infoNode->GetAgeInstanceName(), info->GetAgeInstanceName() )==0 ) |
|
return linkNode; |
|
if ( info->HasAgeFilename() && stricmp( infoNode->GetAgeFilename(), info->GetAgeFilename() )==0 ) |
|
return linkNode; |
|
} |
|
|
|
return nil; |
|
} |
|
|
|
|
|
void plVaultAgeNode::SetAgeGuid( const plUUID * guid ) |
|
{ |
|
fAgeGuid.CopyFrom( guid ); |
|
ISetString64_1( guid->AsStdString().c_str() ); |
|
if ( GetAgeInfo() ) |
|
GetAgeInfo()->SetAgeInstanceGuid( guid ); |
|
} |
|
|
|
void plVaultAgeNode::Save( plVaultOperationCallback * cb/* =nil */, UInt32 cbContext/* =0 */) |
|
{ |
|
if ( GetAgeInfo() ) |
|
GetAgeInfo()->Save(); |
|
plVaultNode::Save( cb, cbContext ); |
|
} |
|
|
|
plVaultAgeInfoNode * plVaultAgeNode::GetAgeInfo() const |
|
{ |
|
if ( fAgeInfo ) |
|
return fAgeInfo; |
|
plVaultAgeInfoNode tmp; |
|
tmp.SetAgeID( GetID() ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeInfo = plVaultAgeInfoNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return fAgeInfo; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeNode::GetAgeDevicesFolder( void ) const |
|
{ |
|
if ( fAgeDevicesFolder ) |
|
return fAgeDevicesFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAgeDevicesFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgeDevicesFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgeDevicesFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgeDevicesFolder node not found" )); |
|
return fAgeDevicesFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeNode::GetSubAgesFolder( void ) const |
|
{ |
|
if ( fSubAgesFolder ) |
|
return fSubAgesFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kSubAgesFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fSubAgesFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fSubAgesFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fSubAgesFolder node not found" )); |
|
return fSubAgesFolder; |
|
} |
|
|
|
plVaultPlayerInfoListNode * plVaultAgeNode::GetPeopleIKnowAboutFolder( void ) const |
|
{ |
|
if ( fPeopleIKnowAboutFolder ) |
|
return fPeopleIKnowAboutFolder; |
|
plVaultPlayerInfoListNode tmp; |
|
tmp.SetFolderType( plVault::kPeopleIKnowAboutFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fPeopleIKnowAboutFolder = plVaultPlayerInfoListNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fPeopleIKnowAboutFolder ) |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fPeopleIKnowAboutFolder node not found" )); |
|
return fPeopleIKnowAboutFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeNode::GetChronicleFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fChronicleFolder && fChronicleFolder != &s_nilNode) |
|
return fChronicleFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kChronicleFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fChronicleFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fChronicleFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fChronicleFolder node not found" )); |
|
fChronicleFolder = &s_nilNode; |
|
} |
|
return fChronicleFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeNode::GetAgesIOwnFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fAgesIOwnFolder && fAgesIOwnFolder != &s_nilNode) |
|
return fAgesIOwnFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kAgesIOwnFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fAgesIOwnFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fAgesIOwnFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fAgesIOwnFolder node not found" )); |
|
fAgesIOwnFolder = &s_nilNode; |
|
} |
|
return fAgesIOwnFolder; |
|
} |
|
|
|
plVaultFolderNode * plVaultAgeNode::GetPublicAgesFolder( void ) const |
|
{ |
|
static plVaultFolderNode s_nilNode; |
|
if ( fPublicAgesFolder && fPublicAgesFolder != &s_nilNode) |
|
return fPublicAgesFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kPublicAgesFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fPublicAgesFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
if ( !fPublicAgesFolder ) { |
|
hsLogEntry(plSafeGetLog()->AddLineF( "fPublicAgesFolder node not found" )); |
|
fPublicAgesFolder = &s_nilNode; |
|
} |
|
return fPublicAgesFolder; |
|
} |
|
|
|
// Add a new device. |
|
void plVaultAgeNode::AddDevice( const char * deviceName, |
|
plVaultOperationCallback * cb /*=nil*/, UInt32 cbContext /*=0*/ ) |
|
{ |
|
plVaultTextNoteNode * device = GetDevice( deviceName ); |
|
if ( !device && fMyNodeMgr) |
|
{ |
|
device = plVaultTextNoteNode::ConvertNoRef( fMyNodeMgr->CreateNode( plVault::kNodeType_TextNote, kNewPersistentNodeOptions( fMyNodeMgr ) ) ); |
|
device->SetTitle( deviceName ); |
|
device->SetNoteType( plVault::kNoteType_Device ); |
|
GetAgeDevicesFolder()->AddNode( device, cb, cbContext ); |
|
} |
|
else |
|
{ |
|
if ( cb ) |
|
{ |
|
cb->fNode = device; |
|
cb->VaultOperationStarted( cbContext ); |
|
cb->VaultOperationComplete( cbContext, device->IsStored()?hsOK:hsFail ); |
|
} |
|
} |
|
} |
|
|
|
// Remove a device. |
|
void plVaultAgeNode::RemoveDevice( const char * deviceName ) |
|
{ |
|
plVaultTextNoteNode * device = GetDevice( deviceName ); |
|
if ( device ) |
|
GetAgeDevicesFolder()->RemoveNode( device->GetID() ); |
|
} |
|
|
|
// True if device exists in age. |
|
bool plVaultAgeNode::HasDevice( const char * deviceName ) |
|
{ |
|
return ( GetDevice( deviceName )!=nil ); |
|
} |
|
|
|
plVaultTextNoteNode * plVaultAgeNode::GetDevice( const char * deviceName ) |
|
{ |
|
GetAgeDevicesFolder(); |
|
hsAssert( fAgeDevicesFolder, "Missing AgeDevicesFolder" ); |
|
plVaultTextNoteNode tmp; |
|
tmp.SetTitle( deviceName ); |
|
tmp.SetNoteType( plVault::kNoteType_Device ); |
|
plVaultNodeRef * nodeRef; |
|
if ( fAgeDevicesFolder->FindNode( &tmp, nodeRef ) ) |
|
return plVaultTextNoteNode::ConvertNoRef( nodeRef->GetChild() ); |
|
hsLogEntry(plSafeGetLog()->AddLineF( "Device %s not found", deviceName )); |
|
return nil; |
|
} |
|
|
|
|
|
plVaultAgeLinkNode * plVaultAgeNode::GetSubAgeLink( const plAgeInfoStruct * info ) const |
|
{ |
|
GetSubAgesFolder(); |
|
hsAssert( fSubAgesFolder, "Missing SubAges folder" ); |
|
return IGetLink( fSubAgesFolder, info ); |
|
} |
|
|
|
plVaultChronicleNode * plVaultAgeNode::FindChronicleEntry( const char * entryName ) |
|
{ |
|
GetChronicleFolder(); |
|
hsAssert( fChronicleFolder, "Missing Chronicle folder" ); |
|
plVaultChronicleNode templateNode; |
|
templateNode.SetName( entryName ); |
|
plVaultNodeRef * tmp; |
|
if ( fChronicleFolder->FindNode( &templateNode, tmp ) ) |
|
return plVaultChronicleNode::ConvertNoRef( tmp->GetChild() ); |
|
return nil; |
|
} |
|
|
|
std::string plVaultAgeNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Guid:%s] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetAgeGuid()->AsStdString().c_str(), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultAdminNode::plVaultAdminNode() |
|
: fAllAgeSDLEventInboxesFolder(nil) |
|
{ |
|
ISetType( plVault::kNodeType_VNodeMgrAdmin ); |
|
} |
|
|
|
plVaultAdminNode::~plVaultAdminNode() |
|
{ |
|
} |
|
|
|
std::string plVaultAdminNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultMarkerNode::plVaultMarkerNode() |
|
{ |
|
ISetType(plVault::kNodeType_Marker); |
|
} |
|
|
|
plVaultMarkerNode::~plVaultMarkerNode() |
|
{ |
|
} |
|
|
|
void plVaultMarkerNode::SetPosition(const hsPoint3& pos) |
|
{ |
|
// To be efficient, write our floats as UInt32's, so we don't have to allocate |
|
// a blob or some crap like that. |
|
UInt32 x = *((UInt32*)&pos.fX); |
|
UInt32 y = *((UInt32*)&pos.fY); |
|
UInt32 z = *((UInt32*)&pos.fZ); |
|
|
|
ISetUInt32_1(x); |
|
ISetUInt32_2(y); |
|
ISetUInt32_3(z); |
|
} |
|
|
|
hsPoint3 plVaultMarkerNode::GetPosition() const |
|
{ |
|
UInt32 uX = IGetUInt32_1(); |
|
UInt32 uY = IGetUInt32_2(); |
|
UInt32 uZ = IGetUInt32_3(); |
|
|
|
float x = *((float*)&uX); |
|
float y = *((float*)&uY); |
|
float z = *((float*)&uZ); |
|
|
|
return hsPoint3(x, y, z); |
|
} |
|
|
|
std::string plVaultMarkerNode::AsStdString(int level) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
hsPoint3 pos = GetPosition(); |
|
xtl::format( result, "%s%s[Text:%s Pos: %.1f,%.1f,%.1f GPS: %d,%d,%d] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetText(), pos.fX, pos.fY, pos.fZ, GetGPSTorans(),GetGPSHSpans(),GetGPSVSpans(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultMarkerListNode::plVaultMarkerListNode() |
|
{ |
|
ISetType(plVault::kNodeType_MarkerList); |
|
} |
|
|
|
plVaultMarkerListNode::~plVaultMarkerListNode() |
|
{ |
|
} |
|
|
|
std::string plVaultMarkerListNode::AsStdString(int level) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[Owner:%s[%d], GameType: %d, RoundLength: %d] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetOwnerName(),GetOwnerID(),GetGameType(),GetRoundLength(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plVaultSystemNode::plVaultSystemNode() |
|
: fGlobalInboxFolder( nil ) |
|
{ |
|
ISetType( plVault::kNodeType_System ); |
|
} |
|
|
|
plVaultFolderNode * plVaultSystemNode::GetGlobalInbox( void ) const |
|
{ |
|
if ( fGlobalInboxFolder ) |
|
return fGlobalInboxFolder; |
|
plVaultFolderNode tmp; |
|
tmp.SetFolderType( plVault::kGlobalInboxFolder ); |
|
plVaultNodeRef * nodeRef; |
|
if ( FindNode( &tmp, nodeRef ) ) |
|
fGlobalInboxFolder = plVaultFolderNode::ConvertNoRef( nodeRef->GetChild() ); |
|
return fGlobalInboxFolder; |
|
} |
|
|
|
|
|
std::string plVaultSystemNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%s%s[CCRAway:%d] %s", |
|
space.c_str(), plVault::NodeTypeStr( GetType() ), |
|
GetCCRAwayStatus(), |
|
plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
//////////////////////////////////////////////////////////////////// |
|
|
|
plNetVaultServerNode::plNetVaultServerNode() |
|
: fCityInfo( nil ) |
|
, fAllPlayersFolderID( 0 ) |
|
, fAllAgeGlobalSDLNodesFolderID( 0 ) |
|
, fPublicAgesFolderID( 0 ) |
|
{ |
|
ISetType( plVault::kNodeType_VNodeMgrServer ); |
|
} |
|
|
|
plNetVaultServerNode::~plNetVaultServerNode() |
|
{ |
|
} |
|
|
|
std::string plNetVaultServerNode::AsStdString( int level ) const |
|
{ |
|
std::string result; |
|
std::string space( level, ' ' ); |
|
xtl::format( result, "%sVAULT[] %s", |
|
space.c_str(), plVaultNode::AsStdString().c_str() ); |
|
return result; |
|
} |
|
|
|
|
|
// End. |
|
|
|
|
|
#endif
|