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.
10 Commits
81 Branches
23 Tags
172 MiB
Tree: ecb7d8b566
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ecb7d8b566'
${ noResults }
CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plVault/plVaultNode.cpp

2743 lines
76 KiB
Raw Normal View History Unescape

Initial Commit of CyanWorlds.com Engine Open Source Client/Plugin
14 years ago
/*==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