OU/CWE-ou-minkata
1
0
Fork 0
mirror of https://foundry.openuru.org/gitblit/r/CWE-ou-minkata.git synced 2025-07-18 11:19:10 +00:00
Code Releases Activity

Replace most vault *IncRef() API functions with hsRef versions

Browse Source
This commit is contained in:
Michael Hansen
2014-05-30 18:22:31 -07:00
parent aa2a1de5d0
commit d2a05929f8
22 changed files with 521 additions and 979 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Sources/Plasma/FeatureLib/pfPython/cyAvatar.cpp
View File

@ -1670,11 +1670,10 @@ void cyAvatar::ChangeAvatar(const char* genderName)
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, genderName, arrsize(wStr));
RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef();
hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode();
if (rvnPlr) {
VaultPlayerNode plr(rvnPlr);
plr.SetAvatarShapeName(wStr);
rvnPlr->UnRef();
}
#endif
}
@ -1691,11 +1690,10 @@ void cyAvatar::ChangePlayerName(const char* playerName)
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, playerName, arrsize(wStr));
RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef();
hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode();
if (rvnPlr) {
VaultPlayerNode plr(rvnPlr);
plr.SetPlayerName(wStr);
rvnPlr->UnRef();
}
}

6
Sources/Plasma/FeatureLib/pfPython/cyMisc.cpp
View File

@ -2471,10 +2471,9 @@ int cyMisc::GetKILevel()
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, pfKIMsg::kChronicleKILevel, arrsize(wStr));
if (RelVaultNode * rvn = VaultFindChronicleEntryIncRef(wStr)) {
if (hsRef<RelVaultNode> rvn = VaultFindChronicleEntry(wStr)) {
VaultChronicleNode chron(rvn);
result = wcstol(chron.GetEntryValue(), nil, 0);
rvn->UnRef();
}
return result;
@ -2880,7 +2879,7 @@ void cyMisc::SetBehaviorNetFlags(pyKey & behKey, bool netForce, bool netProp)
void cyMisc::SendFriendInvite(const wchar_t email[], const wchar_t toName[])
{
if (RelVaultNode* pNode = VaultGetPlayerNodeIncRef())
if (hsRef<RelVaultNode> pNode = VaultGetPlayerNode())
{
VaultPlayerNode player(pNode);
plUUID inviteUuid = player.GetInviteUuid();
@ -2893,7 +2892,6 @@ void cyMisc::SendFriendInvite(const wchar_t email[], const wchar_t toName[])
}
NetCommSendFriendInvite(email, toName, inviteUuid);
pNode->UnRef();
}
}

3
Sources/Plasma/FeatureLib/pfPython/plPythonFileMod.cpp
View File

@ -2079,11 +2079,10 @@ bool plPythonFileMod::MsgReceive(plMessage* msg)
case plVaultNotifyMsg::kRegisteredVisitAge:
case plVaultNotifyMsg::kUnRegisteredOwnedAge:
case plVaultNotifyMsg::kUnRegisteredVisitAge: {
if (RelVaultNode * rvn = VaultGetNodeIncRef(vaultNotifyMsg->GetArgs()->GetInt(plNetCommon::VaultTaskArgs::kAgeLinkNode))) {
if (hsRef<RelVaultNode> rvn = VaultGetNode(vaultNotifyMsg->GetArgs()->GetInt(plNetCommon::VaultTaskArgs::kAgeLinkNode))) {
Py_DECREF(ptuple);
ptuple = PyTuple_New(1);
PyTuple_SetItem(ptuple, 0, pyVaultAgeLinkNode::New(rvn));
rvn->UnRef();
}
}
break;

119
Sources/Plasma/FeatureLib/pfPython/pyAgeVault.cpp
View File

@ -81,12 +81,9 @@ pyAgeVault::~pyAgeVault() {
PyObject* pyAgeVault::GetAgeInfo()
{
RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef();
if (rvn) {
PyObject * result = pyVaultAgeInfoNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgeInfoNode();
if (rvn)
return pyVaultAgeInfoNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -94,12 +91,9 @@ PyObject* pyAgeVault::GetAgeInfo()
PyObject* pyAgeVault::GetAgeDevicesFolder( void )
{
RelVaultNode * rvn = VaultGetAgeDevicesFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgeDevicesFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -107,12 +101,9 @@ PyObject* pyAgeVault::GetAgeDevicesFolder( void )
PyObject* pyAgeVault::GetSubAgesFolder( void )
{
RelVaultNode * rvn = VaultGetAgeSubAgesFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgeSubAgesFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -120,12 +111,9 @@ PyObject* pyAgeVault::GetSubAgesFolder( void )
PyObject* pyAgeVault::GetChronicleFolder( void )
{
RelVaultNode * rvn = VaultGetAgeChronicleFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgeChronicleFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -133,12 +121,9 @@ PyObject* pyAgeVault::GetChronicleFolder( void )
PyObject* pyAgeVault::GetBookshelfFolder ( void )
{
RelVaultNode * rvn = VaultAgeGetBookshelfFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultAgeGetBookshelfFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -146,12 +131,9 @@ PyObject* pyAgeVault::GetBookshelfFolder ( void )
PyObject* pyAgeVault::GetPeopleIKnowAboutFolder( void )
{
RelVaultNode * rvn = VaultGetAgePeopleIKnowAboutFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgePeopleIKnowAboutFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -160,12 +142,9 @@ PyObject* pyAgeVault::GetPeopleIKnowAboutFolder( void )
PyObject* pyAgeVault::GetPublicAgesFolder(void)
{
RelVaultNode * rvn = VaultGetAgePublicAgesFolderIncRef();
if (rvn) {
PyObject * result = pyVaultFolderNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultGetAgePublicAgesFolder();
if (rvn)
return pyVaultFolderNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -173,12 +152,9 @@ PyObject* pyAgeVault::GetPublicAgesFolder(void)
PyObject* pyAgeVault::GetSubAgeLink( const pyAgeInfoStruct & info )
{
RelVaultNode * rvn = VaultFindAgeSubAgeLinkIncRef(info.GetAgeInfo());
if (rvn) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->UnRef();
return result;
}
hsRef<RelVaultNode> rvn = VaultFindAgeSubAgeLink(info.GetAgeInfo());
if (rvn)
return pyVaultAgeLinkNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -186,12 +162,10 @@ PyObject* pyAgeVault::GetSubAgeLink( const pyAgeInfoStruct & info )
plUUID pyAgeVault::GetAgeGuid( void )
{
RelVaultNode * rvn = VaultGetAgeInfoNodeIncRef();
hsRef<RelVaultNode> rvn = VaultGetAgeInfoNode();
if (rvn) {
VaultAgeInfoNode ageInfo(rvn);
plUUID uuid = ageInfo.GetAgeInstanceGuid();
rvn->UnRef();
return uuid;
return ageInfo.GetAgeInstanceGuid();
}
return kNilUuid;
}
@ -204,11 +178,8 @@ PyObject* pyAgeVault::FindChronicleEntry( const char * entryName )
wchar_t wEntryName[kMaxVaultNodeStringLength];
StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
if (RelVaultNode * rvn = VaultFindAgeChronicleEntryIncRef(wEntryName)) {
PyObject * result = pyVaultChronicleNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultFindAgeChronicleEntry(wEntryName))
return pyVaultChronicleNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -235,10 +206,8 @@ void pyAgeVault::AddDevice( const char * deviceName, PyObject * cbObject, uint32
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
if (RelVaultNode * rvn = VaultAgeAddDeviceAndWaitIncRef(wStr)) {
if (hsRef<RelVaultNode> rvn = VaultAgeAddDeviceAndWait(wStr))
cb->SetNode(rvn);
rvn->UnRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail); // cbHolder deletes itself here.
}
@ -266,11 +235,8 @@ PyObject * pyAgeVault::GetDevice( const char * deviceName )
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
if (RelVaultNode * rvn = VaultAgeGetDeviceIncRef(wStr)) {
PyObject * result = pyVaultTextNoteNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultAgeGetDevice(wStr))
return pyVaultTextNoteNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -286,10 +252,8 @@ void pyAgeVault::SetDeviceInbox( const char * deviceName, const char * inboxName
wchar_t wInb[MAX_PATH];
StrToUnicode(wInb, inboxName, arrsize(wInb));
if (RelVaultNode * rvn = VaultAgeSetDeviceInboxAndWaitIncRef(wDev, wInb)) {
if (hsRef<RelVaultNode> rvn = VaultAgeSetDeviceInboxAndWait(wDev, wInb))
cb->SetNode(rvn);
rvn->UnRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail ); // cbHolder deletes itself here.
}
@ -299,11 +263,8 @@ PyObject * pyAgeVault::GetDeviceInbox( const char * deviceName )
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, deviceName, arrsize(wStr));
if (RelVaultNode * rvn = VaultAgeGetDeviceInboxIncRef(wStr)) {
PyObject * result = pyVaultTextNoteNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultAgeGetDeviceInbox(wStr))
return pyVaultTextNoteNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -331,14 +292,10 @@ void pyAgeVault::UpdateAgeSDL( pySDLStateDataRecord & pyrec )
PyObject* pyAgeVault::FindNode( pyVaultNode* templateNode ) const
{
if (RelVaultNode * rvn = VaultGetAgeNodeIncRef()) {
RelVaultNode * find = rvn->GetChildNodeIncRef(templateNode->fNode, 1);
rvn->UnRef();
if (find) {
PyObject * result = pyVaultNode::New(find);
find->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetAgeNode()) {
hsRef<RelVaultNode> find = rvn->GetChildNode(templateNode->fNode, 1);
if (find)
return pyVaultNode::New(find);
}
PYTHON_RETURN_NONE;

13
Sources/Plasma/FeatureLib/pfPython/pyDniInfoSource.cpp
View File

@ -71,7 +71,7 @@ PyObject* pyDniInfoSource::GetAgeCoords( void )
uint32_t pyDniInfoSource::GetAgeTime( void ) const
{
RelVaultNode * node = VaultGetAgeInfoNodeIncRef();
hsRef<RelVaultNode> node = VaultGetAgeInfoNode();
if (!node)
return 0;
@ -81,34 +81,29 @@ uint32_t pyDniInfoSource::GetAgeTime( void ) const
result = (uint32_t)utime->GetSecs();
else
result = 0;
node->UnRef();
return result;
}
const char * pyDniInfoSource::GetAgeName( void ) const
{
RelVaultNode * node = VaultGetAgeInfoNodeIncRef();
hsRef<RelVaultNode> node = VaultGetAgeInfoNode();
if (!node)
return "";
VaultAgeInfoNode ageInfo(node);
fAgeName = StrDupToAnsi(ageInfo.GetAgeInstanceName());
node->UnRef();
return fAgeName;
}
plUUID pyDniInfoSource::GetAgeGuid( void ) const
{
if (RelVaultNode * node = VaultGetAgeInfoNodeIncRef())
if (hsRef<RelVaultNode> node = VaultGetAgeInfoNode())
{
VaultAgeInfoNode ageInfo(node);
plUUID uuid = ageInfo.GetAgeInstanceGuid();
node->UnRef();
return uuid;
return ageInfo.GetAgeInstanceGuid();
}
return kNilUuid;

12
Sources/Plasma/FeatureLib/pfPython/pyGameScore.cpp
View File

@ -125,11 +125,10 @@ void pyGameScore::SetPoints(int32_t numPoints, pyKey& rcvr)
void pyGameScore::CreateAgeScore(const plString& name, uint32_t type, int32_t points, pyKey& rcvr)
{
if (RelVaultNode* ageInfo = VaultGetAgeInfoNodeIncRef())
if (hsRef<RelVaultNode> ageInfo = VaultGetAgeInfoNode())
{
uint32_t ownerId = ageInfo->GetNodeId();
pfGameScore::Create(ownerId, name, type, points, rcvr.getKey());
ageInfo->UnRef();
} else
hsAssert(false, "Age has no vault... Need to rewrite score python script?");
}
@ -141,11 +140,10 @@ void pyGameScore::CreateGlobalScore(const plString& name, uint32_t type, int32_t
void pyGameScore::CreatePlayerScore(const plString& name, uint32_t type, int32_t points, pyKey& rcvr)
{
if (RelVaultNode* node = VaultGetPlayerInfoNodeIncRef())
if (hsRef<RelVaultNode> node = VaultGetPlayerInfoNode())
{
uint32_t ownerId = node->GetNodeId();
pfGameScore::Create(ownerId, name, type, points, rcvr.getKey());
node->UnRef();
} else
hsAssert(false, "No PlayerInfo node... Need to rewrite python script?");
}
@ -157,11 +155,10 @@ void pyGameScore::CreateScore(uint32_t ownerId, const plString& name, uint32_t t
void pyGameScore::FindAgeScores(const plString& name, pyKey& rcvr)
{
if (RelVaultNode* ageInfo = VaultGetAgeInfoNodeIncRef())
if (hsRef<RelVaultNode> ageInfo = VaultGetAgeInfoNode())
{
uint32_t ownerId = ageInfo->GetNodeId();
pfGameScore::Find(ownerId, name, rcvr.getKey());
ageInfo->UnRef();
} else
hsAssert(false, "Age has no vault... Need to rewrite score python script?");
}
@ -173,11 +170,10 @@ void pyGameScore::FindGlobalScores(const plString& name, pyKey& rcvr)
void pyGameScore::FindPlayerScores(const plString& name, pyKey& rcvr)
{
if (RelVaultNode* node = VaultGetPlayerInfoNodeIncRef())
if (hsRef<RelVaultNode> node = VaultGetPlayerInfoNode())
{
uint32_t ownerId = node->GetNodeId();
pfGameScore::Find(ownerId, name, rcvr.getKey());
node->UnRef();
}
else
hsAssert(false, "No PlayerInfo node.. Need to rewrite python script?");

130
Sources/Plasma/FeatureLib/pfPython/pyVault.cpp
View File

@ -81,12 +81,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
//============================================================================
static PyObject * GetFolder (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildFolderNodeIncRef(folderType, 1)) {
if (hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode()) {
if (hsRef<RelVaultNode> rvnFldr = rvnPlr->GetChildFolderNode(folderType, 1))
result = pyVaultFolderNode::New(rvnFldr);
rvnFldr->UnRef();
}
rvnPlr->UnRef();
}
return result;
@ -95,12 +92,9 @@ static PyObject * GetFolder (unsigned folderType) {
//============================================================================
static PyObject * GetPlayerInfoList (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildPlayerInfoListNodeIncRef(folderType, 1)) {
if (hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode()) {
if (hsRef<RelVaultNode> rvnFldr = rvnPlr->GetChildPlayerInfoListNode(folderType, 1))
result = pyVaultPlayerInfoListNode::New(rvnFldr);
rvnFldr->UnRef();
}
rvnPlr->UnRef();
}
return result;
@ -109,12 +103,9 @@ static PyObject * GetPlayerInfoList (unsigned folderType) {
//============================================================================
static PyObject * GetAgeInfoList (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildAgeInfoListNodeIncRef(folderType, 1)) {
if (hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode()) {
if (hsRef<RelVaultNode> rvnFldr = rvnPlr->GetChildAgeInfoListNode(folderType, 1))
result = pyVaultAgeInfoListNode::New(rvnFldr);
rvnFldr->UnRef();
}
rvnPlr->UnRef();
}
return result;
@ -124,12 +115,9 @@ static PyObject * GetAgeInfoList (unsigned folderType) {
PyObject* pyVault::GetPlayerInfo()
{
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnPlrInfo = rvnPlr->GetChildNodeIncRef(plVault::kNodeType_PlayerInfo, 1)) {
if (hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode()) {
if (hsRef<RelVaultNode> rvnPlrInfo = rvnPlr->GetChildNode(plVault::kNodeType_PlayerInfo, 1))
result = pyVaultPlayerInfoNode::New(rvnPlrInfo);
rvnPlrInfo->UnRef();
}
rvnPlr->UnRef();
}
// just return an empty node
@ -208,12 +196,12 @@ PyObject* pyVault::GetKIUsage(void)
uint32_t markerGames = 0;
for (;;) {
RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef();
hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode();
if (!rvnPlr)
break;
for (;;) {
RelVaultNode * rvnAgeJrnlz = rvnPlr->GetChildFolderNodeIncRef(plVault::kAgeJournalsFolder, 1);
hsRef<RelVaultNode> rvnAgeJrnlz = rvnPlr->GetChildFolderNode(plVault::kAgeJournalsFolder, 1);
if (!rvnAgeJrnlz)
break;
@ -234,10 +222,8 @@ PyObject* pyVault::GetKIUsage(void)
rvn->UnRef();
}
rvnAgeJrnlz->UnRef();
break;
}
rvnPlr->UnRef();
break;
}
@ -303,11 +289,8 @@ PyObject* pyVault::GetLinkToMyNeighborhood() const
plAgeInfoStruct info;
info.SetAgeFilename(kNeighborhoodAgeFilename);
if (RelVaultNode * rvn = VaultGetOwnedAgeLinkIncRef(&info)) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetOwnedAgeLink(&info))
return pyVaultAgeLinkNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -317,11 +300,8 @@ PyObject* pyVault::GetLinkToCity() const
plAgeInfoStruct info;
info.SetAgeFilename(kCityAgeFilename);
if (RelVaultNode * rvn = VaultGetOwnedAgeLinkIncRef(&info)) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetOwnedAgeLink(&info))
return pyVaultAgeLinkNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -330,11 +310,8 @@ PyObject* pyVault::GetLinkToCity() const
// Owned ages
PyObject* pyVault::GetOwnedAgeLink( const pyAgeInfoStruct & info )
{
if (RelVaultNode * rvnLink = VaultGetOwnedAgeLinkIncRef(info.GetAgeInfo())) {
PyObject * result = pyVaultAgeLinkNode::New(rvnLink);
rvnLink->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvnLink = VaultGetOwnedAgeLink(info.GetAgeInfo()))
return pyVaultAgeLinkNode::New(rvnLink);
// just return a None object
PYTHON_RETURN_NONE;
@ -343,11 +320,8 @@ PyObject* pyVault::GetOwnedAgeLink( const pyAgeInfoStruct & info )
// Visit ages
PyObject* pyVault::GetVisitAgeLink( const pyAgeInfoStruct & info)
{
if (RelVaultNode * rvnLink = VaultGetVisitAgeLinkIncRef(info.GetAgeInfo())) {
PyObject * result = pyVaultAgeLinkNode::New(rvnLink);
rvnLink->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvnLink = VaultGetVisitAgeLink(info.GetAgeInfo()))
return pyVaultAgeLinkNode::New(rvnLink);
// just return a None object
PYTHON_RETURN_NONE;
@ -361,11 +335,8 @@ PyObject* pyVault::FindChronicleEntry( const char * entryName )
wchar_t wEntryName[kMaxVaultNodeStringLength];
StrToUnicode(wEntryName, entryName, arrsize(wEntryName));
if (RelVaultNode * rvn = VaultFindChronicleEntryIncRef(wEntryName)) {
PyObject * result = pyVaultChronicleNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultFindChronicleEntry(wEntryName))
return pyVaultChronicleNode::New(rvn);
// just return a None object
PYTHON_RETURN_NONE;
@ -441,10 +412,9 @@ PyObject* pyVault::GetInviteFolder()
PyObject* pyVault::GetPsnlAgeSDL() const
{
PyObject * result = nil;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
if (RelVaultNode * rvnFldr = VaultGetAgesIOwnFolderIncRef()) {
if (hsRef<RelVaultNode> rvnFldr = VaultGetAgesIOwnFolder()) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
@ -453,27 +423,22 @@ PyObject* pyVault::GetPsnlAgeSDL() const
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (RelVaultNode * rvnInfo = rvnFldr->GetChildNodeIncRef(templateNode, 2)) {
if (hsRef<RelVaultNode> rvnInfo = rvnFldr->GetChildNode(templateNode, 2)) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (RelVaultNode * rvnSdl = rvnInfo->GetChildNodeIncRef(templateNode, 1)) {
if (hsRef<RelVaultNode> rvnSdl = rvnInfo->GetChildNode(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
plStateDataRecord * rec = new plStateDataRecord;
if (sdl.GetStateDataRecord(rec, plSDL::kKeepDirty))
result = pySDLStateDataRecord::New(rec);
else
delete rec;
rvnSdl->UnRef();
}
rvnInfo->UnRef();
}
rvnFldr->UnRef();
}
templateNode->UnRef();
if (!result)
PYTHON_RETURN_NONE;
@ -486,10 +451,9 @@ void pyVault::UpdatePsnlAgeSDL( pySDLStateDataRecord & pyrec )
if ( !rec )
return;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
if (RelVaultNode * rvnFldr = VaultGetAgesIOwnFolderIncRef()) {
if (hsRef<RelVaultNode> rvnFldr = VaultGetAgesIOwnFolder()) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_AgeInfo);
@ -498,22 +462,17 @@ void pyVault::UpdatePsnlAgeSDL( pySDLStateDataRecord & pyrec )
StrToUnicode(str, kPersonalAgeFilename, arrsize(str));
ageInfo.SetAgeFilename(str);
if (RelVaultNode * rvnInfo = rvnFldr->GetChildNodeIncRef(templateNode, 2)) {
if (hsRef<RelVaultNode> rvnInfo = rvnFldr->GetChildNode(templateNode, 2)) {
templateNode->ClearFieldFlags();
templateNode->SetNodeType(plVault::kNodeType_SDL);
if (RelVaultNode * rvnSdl = rvnInfo->GetChildNodeIncRef(templateNode, 1)) {
if (hsRef<RelVaultNode> rvnSdl = rvnInfo->GetChildNode(templateNode, 1)) {
VaultSDLNode sdl(rvnSdl);
sdl.SetStateDataRecord(rec, plSDL::kDirtyOnly | plSDL::kTimeStampOnRead);
rvnSdl->UnRef();
}
rvnInfo->UnRef();
}
rvnFldr->UnRef();
}
templateNode->UnRef();
}
bool pyVault::InMyPersonalAge() const
@ -622,24 +581,19 @@ void pyVault::UnInvitePlayerToAge( const char * str, uint32_t playerID )
plUUID guid(str);
info.SetAgeInstanceGuid(&guid);
if (RelVaultNode * rvnLink = VaultGetOwnedAgeLinkIncRef(&info)) {
if (RelVaultNode * rvnInfo = rvnLink->GetChildNodeIncRef(plVault::kNodeType_AgeInfo, 1)) {
if (hsRef<RelVaultNode> rvnLink = VaultGetOwnedAgeLink(&info)) {
if (hsRef<RelVaultNode> rvnInfo = rvnLink->GetChildNode(plVault::kNodeType_AgeInfo, 1)) {
VaultAgeInfoNode ageInfo(rvnInfo);
ageInfo.CopyTo(&info);
rvnInfo->UnRef();
}
rvnLink->UnRef();
}
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
templateNode->SetNodeType(plVault::kNodeType_TextNote);
VaultTextNoteNode visitAcc(templateNode);
visitAcc.SetNoteType(plVault::kNoteType_UnVisit);
visitAcc.SetVisitInfo(info);
VaultCreateNode(templateNode, (FVaultCreateNodeCallback)_UninvitePlayerToAge, nil, (void*)playerID);
templateNode->UnRef();
}
//============================================================================
@ -696,12 +650,8 @@ bool pyVault::SetAgePublic( const pyAgeInfoStruct * ageInfo, bool makePublic )
PyObject* pyVault::GetGlobalInbox()
{
PyObject * result = nil;
if (RelVaultNode * rvnGlobalInbox = VaultGetGlobalInboxIncRef()) {
result = pyVaultFolderNode::New(rvnGlobalInbox);
rvnGlobalInbox->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvnGlobalInbox = VaultGetGlobalInbox())
return pyVaultFolderNode::New(rvnGlobalInbox);
PYTHON_RETURN_NONE;
}
@ -712,11 +662,8 @@ PyObject* pyVault::GetGlobalInbox()
PyObject* pyVault::FindNode( pyVaultNode* templateNode ) const
{
// See if we already have a matching node locally
if (RelVaultNode * rvn = VaultGetNodeIncRef(templateNode->GetNode())) {
PyObject * result = pyVaultNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetNode(templateNode->GetNode()))
return pyVaultNode::New(rvn);
// See if a matching node exists on the server
ARRAY(unsigned) nodeIds;
@ -726,11 +673,8 @@ PyObject* pyVault::FindNode( pyVaultNode* templateNode ) const
// Only fetch the first matching node since this function returns a single node
VaultFetchNodesAndWait(&nodeIds[0], 1);
// If we fetched it successfully then it'll be in our local node cache now
if (RelVaultNode * rvn = VaultGetNodeIncRef(nodeIds[0])) {
PyObject * result = pyVaultNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetNode(nodeIds[0]))
return pyVaultNode::New(rvn);
}
PYTHON_RETURN_NONE;

15
Sources/Plasma/FeatureLib/pfPython/pyVaultAgeInfoNode.cpp
View File

@ -89,20 +89,16 @@ static PyObject * GetChildFolder (RelVaultNode * node, unsigned type) {
//============================================================================
static PyObject * GetChildPlayerInfoList (RelVaultNode * node, unsigned type) {
PyObject * result = nil;
if (RelVaultNode * rvn = node->GetChildPlayerInfoListNodeIncRef(type, 1)) {
if (hsRef<RelVaultNode> rvn = node->GetChildPlayerInfoListNode(type, 1))
result = pyVaultPlayerInfoListNode::New(rvn);
rvn->UnRef();
}
return result;
}
//============================================================================
static PyObject * GetChildAgeInfoList (RelVaultNode * node, unsigned type) {
PyObject * result = nil;
if (RelVaultNode * rvn = node->GetChildAgeInfoListNodeIncRef(type, 1)) {
if (hsRef<RelVaultNode> rvn = node->GetChildAgeInfoListNode(type, 1))
result = pyVaultAgeInfoListNode::New(rvn);
rvn->UnRef();
}
return result;
}
@ -173,11 +169,8 @@ PyObject * pyVaultAgeInfoNode::GetParentAgeLink () const
if (!fNode)
PYTHON_RETURN_NONE;
if (RelVaultNode * rvn = fNode->GetParentAgeLinkIncRef()) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = fNode->GetParentAgeLink())
return pyVaultAgeLinkNode::New(rvn);
// just return a None object.
PYTHON_RETURN_NONE

4
Sources/Plasma/FeatureLib/pfPython/pyVaultAgeLinkNode.cpp
View File

@ -82,10 +82,8 @@ PyObject* pyVaultAgeLinkNode::GetAgeInfo() const
PYTHON_RETURN_NONE;
PyObject * result = nil;
if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(plVault::kNodeType_AgeInfo, 1)) {
if (hsRef<RelVaultNode> rvn = fNode->GetChildNode(plVault::kNodeType_AgeInfo, 1))
result = pyVaultAgeInfoNode::New(rvn);
rvn->UnRef();
}
if (result)
return result;

47
Sources/Plasma/FeatureLib/pfPython/pyVaultNode.cpp
View File

@ -270,17 +270,13 @@ PyObject* pyVaultNode::GetCreatorNode( void )
PyObject * result = nil;
if (fNode)
{
RelVaultNode * templateNode = new RelVaultNode;
templateNode->Ref();
hsRef<RelVaultNode> templateNode = new RelVaultNode;
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode plrInfo(templateNode);
plrInfo.SetPlayerId(fNode->GetCreatorId());
if (RelVaultNode * rvn = VaultGetNodeIncRef(templateNode)) {
if (hsRef<RelVaultNode> rvn = VaultGetNode(templateNode))
result = pyVaultPlayerInfoNode::New(rvn);
rvn->UnRef();
}
templateNode->UnRef();
}
if (result)
@ -417,7 +413,7 @@ PyObject* pyVaultNode::AddNode(pyVaultNode* pynode, PyObject* cbObject, uint32_t
// Block here until node is created and fetched =(
ASSERT(pynode->GetNode()->GetNodeType());
ENetError result;
RelVaultNode * newNode = VaultCreateNodeAndWaitIncRef(
hsRef<RelVaultNode> newNode = VaultCreateNodeAndWait(
pynode->GetNode(),
&result
);
@ -468,10 +464,9 @@ void pyVaultNode::LinkToNode(int nodeID, PyObject* cbObject, uint32_t cbContext)
// Hack the callbacks until vault notification is in place
cb->VaultOperationStarted( cbContext );
if (RelVaultNode * rvn = VaultGetNodeIncRef(nodeID)) {
if (hsRef<RelVaultNode> rvn = VaultGetNode(nodeID)) {
cb->SetNode(rvn);
cb->fPyNodeRef = pyVaultNodeRef::New(fNode, rvn);
rvn->UnRef();
}
VaultAddChildNode(fNode->GetNodeId(),
@ -535,7 +530,8 @@ void pyVaultNode::Save(PyObject* cbObject, uint32_t cbContext)
// otherwise just ignore the save request since vault nodes are now auto-saved.
if (!fNode->GetNodeId() && fNode->GetNodeType()) {
ENetError result;
if (RelVaultNode * node = VaultCreateNodeAndWaitIncRef(fNode, &result)) {
if (hsRef<RelVaultNode> node = VaultCreateNodeAndWait(fNode, &result)) {
node->Ref();
fNode->UnRef();
fNode = node;
}
@ -559,7 +555,8 @@ void pyVaultNode::ForceSave()
{
if (!fNode->GetNodeId() && fNode->GetNodeType()) {
ENetError result;
if (RelVaultNode * node = VaultCreateNodeAndWaitIncRef(fNode, &result)) {
if (hsRef<RelVaultNode> node = VaultCreateNodeAndWait(fNode, &result)) {
node->Ref();
fNode->UnRef();
fNode = node;
}
@ -578,7 +575,8 @@ void pyVaultNode::SendTo(uint32_t destClientNodeID, PyObject* cbObject, uint32_t
// If the node doesn't have an id, then use it as a template to create the node in the vault,
if (!fNode->GetNodeId() && fNode->GetNodeType()) {
ENetError result;
if (RelVaultNode * node = VaultCreateNodeAndWaitIncRef(fNode, &result)) {
if (hsRef<RelVaultNode> node = VaultCreateNodeAndWait(fNode, &result)) {
node->Ref();
fNode->UnRef();
fNode = node;
}
@ -656,14 +654,10 @@ PyObject * pyVaultNode::GetNode2( uint32_t nodeID ) const
PyObject * result = nil;
if ( fNode )
{
RelVaultNode * templateNode = new RelVaultNode;
templateNode->Ref();
hsRef<RelVaultNode> templateNode = new RelVaultNode;
templateNode->SetNodeId(nodeID);
if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1)) {
if (hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode, 1))
result = pyVaultNodeRef::New(fNode, rvn);
rvn->UnRef();
}
templateNode->UnRef();
}
if (result)
@ -677,10 +671,8 @@ PyObject* pyVaultNode::FindNode( pyVaultNode * templateNode )
PyObject * result = nil;
if ( fNode && templateNode->fNode )
{
if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode->fNode, 1)) {
if (hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode->fNode, 1))
result = pyVaultNode::New(rvn);
rvn->UnRef();
}
}
if (result)
@ -694,17 +686,12 @@ PyObject * pyVaultNode::GetChildNode (unsigned nodeId) {
if (!fNode)
PYTHON_RETURN_NONE;
RelVaultNode * templateNode = new RelVaultNode;
templateNode->Ref();
hsRef<RelVaultNode> templateNode = new RelVaultNode;
templateNode->SetNodeId(nodeId);
RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1);
templateNode->UnRef();
hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode, 1);
if (rvn) {
PyObject * result = pyVaultNode::New(rvn);
rvn->UnRef();
return result;
}
if (rvn)
return pyVaultNode::New(rvn);
PYTHON_RETURN_NONE;
}

22
Sources/Plasma/FeatureLib/pfPython/pyVaultNodeRef.cpp
View File

@ -113,10 +113,8 @@ unsigned pyVaultNodeRef::GetSaverID () {
return 0;
unsigned saverId = 0;
if (RelVaultNode * child = VaultGetNodeIncRef(fChild->GetNodeId())) {
if (hsRef<RelVaultNode> child = VaultGetNode(fChild->GetNodeId()))
saverId = child->GetRefOwnerId(fParent->GetNodeId());
child->UnRef();
}
return saverId;
}
@ -124,36 +122,30 @@ PyObject * pyVaultNodeRef::GetSaver () {
if (!fParent || !fChild)
return 0;
RelVaultNode * saver = nil;
if (RelVaultNode * child = VaultGetNodeIncRef(fChild->GetNodeId())) {
hsRef<RelVaultNode> saver;
if (hsRef<RelVaultNode> child = VaultGetNode(fChild->GetNodeId())) {
if (unsigned saverId = child->GetRefOwnerId(fParent->GetNodeId())) {
// Find the player info node representing the saver
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(saverId);
saver = VaultGetNodeIncRef(templateNode);
saver = VaultGetNode(templateNode);
if (!saver) {
ARRAY(unsigned) nodeIds;
VaultFindNodesAndWait(templateNode, &nodeIds);
if (nodeIds.Count() > 0) {
VaultFetchNodesAndWait(nodeIds.Ptr(), nodeIds.Count());
saver = VaultGetNodeIncRef(nodeIds[0]);
saver = VaultGetNode(nodeIds[0]);
}
}
templateNode->UnRef();
}
child->UnRef();
}
if (!saver)
PYTHON_RETURN_NONE;
PyObject * result = pyVaultPlayerInfoNode::New(saver);
saver->UnRef();
return result;
return pyVaultPlayerInfoNode::New(saver);
}
bool pyVaultNodeRef::BeenSeen () {

26
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerInfoListNode.cpp
View File

@ -79,17 +79,13 @@ bool pyVaultPlayerInfoListNode::HasPlayer( uint32_t playerID )
if (!fNode)
return false;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(playerID);
RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1);
if (rvn)
rvn->UnRef();
hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode, 1);
templateNode->UnRef();
return (rvn != nil);
}
@ -131,18 +127,13 @@ void pyVaultPlayerInfoListNode::RemovePlayer( uint32_t playerID )
if (!fNode)
return;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(playerID);
if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1)) {
if (hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode, 1))
VaultRemoveChildNode(fNode->GetNodeId(), rvn->GetNodeId(), nil, nil);
rvn->UnRef();
}
templateNode->UnRef();
}
PyObject * pyVaultPlayerInfoListNode::GetPlayer( uint32_t playerID )
@ -150,19 +141,14 @@ PyObject * pyVaultPlayerInfoListNode::GetPlayer( uint32_t playerID )
if (!fNode)
PYTHON_RETURN_NONE;
NetVaultNode * templateNode = new NetVaultNode;
templateNode->Ref();
hsRef<NetVaultNode> templateNode = new NetVaultNode;
templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
VaultPlayerInfoNode access(templateNode);
access.SetPlayerId(playerID);
PyObject * result = nil;
if (RelVaultNode * rvn = fNode->GetChildNodeIncRef(templateNode, 1)) {
if (hsRef<RelVaultNode> rvn = fNode->GetChildNode(templateNode, 1))
result = pyVaultPlayerInfoNode::New(rvn);
rvn->UnRef();
}
templateNode->UnRef();
if (!result)
PYTHON_RETURN_NONE;

28
Sources/Plasma/FeatureLib/pfPython/pyVaultPlayerNode.cpp
View File

@ -65,12 +65,9 @@ You can contact Cyan Worlds, Inc. by email legal@cyan.com
//============================================================================
static PyObject * GetPlayerVaultFolder (unsigned folderType) {
PyObject * result = nil;
if (RelVaultNode * rvnPlr = VaultGetPlayerNodeIncRef()) {
if (RelVaultNode * rvnFldr = rvnPlr->GetChildFolderNodeIncRef(folderType, 1)) {
if (hsRef<RelVaultNode> rvnPlr = VaultGetPlayerNode()) {
if (hsRef<RelVaultNode> rvnFldr = rvnPlr->GetChildFolderNode(folderType, 1))
result = pyVaultFolderNode::New(rvnFldr);
rvnFldr->UnRef();
}
rvnPlr->UnRef();
}
return result;
@ -172,11 +169,8 @@ PyObject *pyVaultPlayerNode::GetAgesIOwnFolder()
PyObject *pyVaultPlayerNode::GetPlayerInfo()
{
if (RelVaultNode * rvn = VaultGetPlayerInfoNodeIncRef()) {
PyObject * result = pyVaultPlayerInfoNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetPlayerInfoNode())
return pyVaultPlayerInfoNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -221,11 +215,8 @@ void pyVaultPlayerNode::RemoveOwnedAgeLink(const char* ageFilename)
PyObject *pyVaultPlayerNode::GetVisitAgeLink(const pyAgeInfoStruct *info)
{
if (RelVaultNode * rvn = VaultGetVisitAgeLinkIncRef(info->GetAgeInfo())) {
PyObject * result = pyVaultAgeLinkNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultGetVisitAgeLink(info->GetAgeInfo()))
return pyVaultAgeLinkNode::New(rvn);
PYTHON_RETURN_NONE;
}
@ -242,11 +233,8 @@ PyObject *pyVaultPlayerNode::FindChronicleEntry(const char *entryName)
{
wchar_t wStr[MAX_PATH];
StrToUnicode(wStr, entryName, arrsize(wStr));
if (RelVaultNode * rvn = VaultFindChronicleEntryIncRef(wStr)) {
PyObject * result = pyVaultChronicleNode::New(rvn);
rvn->UnRef();
return result;
}
if (hsRef<RelVaultNode> rvn = VaultFindChronicleEntry(wStr))
return pyVaultChronicleNode::New(rvn);
PYTHON_RETURN_NONE;
}

4
Sources/Plasma/FeatureLib/pfPython/pyVaultTextNoteNode.cpp
View File

@ -228,10 +228,8 @@ void pyVaultTextNoteNode::SetDeviceInbox( const char * devName, PyObject * cbObj
wchar_t wDev[MAX_PATH];
StrToUnicode(wDev, devName, arrsize(wDev));
if (RelVaultNode * rvn = VaultAgeSetDeviceInboxAndWaitIncRef(wDev, DEFAULT_DEVICE_INBOX)) {
if (hsRef<RelVaultNode> rvn = VaultAgeSetDeviceInboxAndWait(wDev, DEFAULT_DEVICE_INBOX))
cb->SetNode(rvn);
rvn->UnRef();
}
cb->VaultOperationComplete( cbContext, cb->GetNode() ? hsOK : hsFail ); // cbHolder deletes itself here.
}