CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pyVaultNodeRef.cpp

/*==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==*/
//////////////////////////////////////////////////////////////////////
//
// pyVaultNodeRef   - a wrapper class to provide interface to the plVaultNodeRef
//
//////////////////////////////////////////////////////////////////////

#include "pyVaultNodeRef.h"
#ifndef BUILDING_PYPLASMA
#include "pyVault.h"
#endif
#include "pyVaultNode.h"
#include "pyVaultPlayerInfoNode.h"

#include "plVault/plVault.h"


//////////////////////////////////////////////////////////////////////


// should only be created from C++ side
pyVaultNodeRef::pyVaultNodeRef(RelVaultNode * parent, RelVaultNode * child)
: fParent(parent)
, fChild(child)
{
    fParent->IncRef();
    fChild->IncRef();
}

pyVaultNodeRef::pyVaultNodeRef(int)
: fParent(nil)
, fChild(nil)
{
}

pyVaultNodeRef::~pyVaultNodeRef()
{
    if (fParent)
        fParent->DecRef();
    if (fChild)
        fChild->DecRef();
}


///////////////////////////////////////////////////////////////////////////

PyObject* pyVaultNodeRef::GetParent ( void )
{
    return pyVaultNode::New(fParent);
}

PyObject* pyVaultNodeRef::GetChild( void )
{
    return pyVaultNode::New(fChild);
}

unsigned pyVaultNodeRef::GetParentID () {
    if (!fParent)
        return 0;
    return fParent->nodeId;
}

unsigned pyVaultNodeRef::GetChildID () {
    if (!fChild)
        return 0;
    return fChild->nodeId;
}

unsigned pyVaultNodeRef::GetSaverID () {
    if (!fParent || !fChild)
        return 0;

    unsigned saverId = 0;       
    if (RelVaultNode * child = VaultGetNodeIncRef(fChild->nodeId)) {
        saverId = child->GetRefOwnerId(fParent->nodeId);
        child->DecRef();
    }
    return saverId;
}

PyObject * pyVaultNodeRef::GetSaver () {
    if (!fParent || !fChild)
        return 0;

    RelVaultNode * saver = nil;     
    if (RelVaultNode * child = VaultGetNodeIncRef(fChild->nodeId)) {
        if (unsigned saverId = child->GetRefOwnerId(fParent->nodeId)) {
            // Find the player info node representing the saver
            NetVaultNode * templateNode = NEWZERO(NetVaultNode);
            templateNode->IncRef();
            templateNode->SetNodeType(plVault::kNodeType_PlayerInfo);
            VaultPlayerInfoNode access(templateNode);
            access.SetPlayerId(saverId);
            saver = VaultGetNodeIncRef(templateNode);

            if (!saver) {
                ARRAY(unsigned) nodeIds;
                VaultFindNodesAndWait(templateNode, &nodeIds);
                if (nodeIds.Count() > 0) {
                    VaultFetchNodesAndWait(nodeIds.Ptr(), nodeIds.Count());
                    saver = VaultGetNodeIncRef(nodeIds[0]);
                }
            }

            templateNode->DecRef();
        }
        child->DecRef();
    }
    if (!saver)
        PYTHON_RETURN_NONE;
        
    PyObject * result = pyVaultPlayerInfoNode::New(saver);
    saver->DecRef();
    return result;
}

bool pyVaultNodeRef::BeenSeen () {
    return false;
}

void pyVaultNodeRef::SetSeen (bool v) {
    if (!fParent || !fChild)
        return;
        
    fParent->SetSeen(fChild->nodeId, v);
}