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.
 
 
 
 
 

545 lines
18 KiB

/*==LICENSE==*
CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011 Cyan Worlds, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
You can contact Cyan Worlds, Inc. by email legal@cyan.com
or by snail mail at:
Cyan Worlds, Inc.
14617 N Newport Hwy
Mead, WA 99021
*==LICENSE==*/
#include "pyVaultNode.h"
#include "plVault/plVault.h"
#include <python.h>
// glue functions
PYTHON_CLASS_DEFINITION(ptVaultNode, pyVaultNode);
PYTHON_DEFAULT_NEW_DEFINITION(ptVaultNode, pyVaultNode)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptVaultNode)
PYTHON_NO_INIT_DEFINITION(ptVaultNode)
PYTHON_RICH_COMPARE_DEFINITION(ptVaultNode, obj1, obj2, compareType)
{
if ((obj1 == Py_None) || (obj2 == Py_None))
{
bool isEqual = (obj1 == obj2);
if (compareType == Py_EQ)
{
if (isEqual)
PYTHON_RCOMPARE_TRUE;
else
PYTHON_RCOMPARE_FALSE;
}
else if (compareType == Py_NE)
{
if (isEqual)
PYTHON_RCOMPARE_FALSE;
else
PYTHON_RCOMPARE_TRUE;
}
PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptVaultNode object");
PYTHON_RCOMPARE_ERROR;
}
if (!pyVaultNode::Check(obj1) || !pyVaultNode::Check(obj2))
{
PyErr_SetString(PyExc_NotImplementedError, "cannot compare ptVaultNode objects to non-ptVaultNode objects");
PYTHON_RCOMPARE_ERROR;
}
pyVaultNode *vnObj1 = pyVaultNode::ConvertFrom(obj1);
pyVaultNode *vnObj2 = pyVaultNode::ConvertFrom(obj2);
if (compareType == Py_EQ)
{
if ((*vnObj1) == (*vnObj2))
PYTHON_RCOMPARE_TRUE;
PYTHON_RCOMPARE_FALSE;
}
else if (compareType == Py_NE)
{
if ((*vnObj1) != (*vnObj2))
PYTHON_RCOMPARE_TRUE;
PYTHON_RCOMPARE_FALSE;
}
PyErr_SetString(PyExc_NotImplementedError, "invalid comparison for a ptVaultNode object");
PYTHON_RCOMPARE_ERROR;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getID)
{
return PyLong_FromUnsignedLong(self->fThis->GetID());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getType)
{
return PyLong_FromUnsignedLong(self->fThis->GetType());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getOwnerNodeID)
{
return PyLong_FromUnsignedLong(self->fThis->GetOwnerNodeID());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getOwnerNode)
{
return self->fThis->GetOwnerNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getModifyTime)
{
return PyLong_FromUnsignedLong(self->fThis->GetModifyTime());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreatorNodeID)
{
return PyLong_FromUnsignedLong(self->fThis->GetCreatorNodeID());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreatorNode)
{
return self->fThis->GetCreatorNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreateTime)
{
return PyLong_FromUnsignedLong(self->fThis->GetCreateTime());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreateAgeTime)
{
return PyLong_FromUnsignedLong(self->fThis->GetCreateAgeTime());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreateAgeName)
{
return PyString_FromString(self->fThis->GetCreateAgeName());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreateAgeGuid)
{
return PyString_FromString(self->fThis->GetCreateAgeGuid());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getCreateAgeCoords)
{
return self->fThis->GetCreateAgeCoords();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getChildNodeRefList)
{
return self->fThis->GetChildNodeRefList();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getChildNodeCount)
{
return PyInt_FromLong(self->fThis->GetChildNodeCount());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, getClientID)
{
return PyLong_FromUnsignedLong(self->fThis->GetClientID());
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setID, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "setID expects an unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetID(id);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setType, args)
{
int nodeType;
if (!PyArg_ParseTuple(args, "i", &nodeType))
{
PyErr_SetString(PyExc_TypeError, "setType expects an int");
PYTHON_RETURN_ERROR;
}
self->fThis->SetType(nodeType);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setOwnerNodeID, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "setOwnerNodeID expects an unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetOwnerNodeID(id);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setCreatorNodeID, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "setCreatorNodeID expects an unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetCreatorNodeID(id);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setCreateAgeName, args)
{
char* name;
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError, "setCreateAgeName expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->SetCreateAgeName(name);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, setCreateAgeGuid, args)
{
char* guid;
if (!PyArg_ParseTuple(args, "s", &guid))
{
PyErr_SetString(PyExc_TypeError, "setCreateAgeGuid expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->SetCreateAgeGuid(guid);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptVaultNode, removeAllNodes, RemoveAllNodes)
PYTHON_METHOD_DEFINITION(ptVaultNode, hasNode, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "hasNode expects an unsigned long");
PYTHON_RETURN_ERROR;
}
PYTHON_RETURN_BOOL(self->fThis->HasNode(id));
}
PYTHON_METHOD_DEFINITION(ptVaultNode, getNode, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "getNode expects an unsigned long");
PYTHON_RETURN_ERROR;
}
return self->fThis->GetNode2(id);
}
PYTHON_METHOD_DEFINITION(ptVaultNode, getChildNode, args)
{
unsigned long id;
if (!PyArg_ParseTuple(args, "l", &id))
{
PyErr_SetString(PyExc_TypeError, "getNode expects an unsigned long");
PYTHON_RETURN_ERROR;
}
return self->fThis->GetChildNode(id);
}
PYTHON_METHOD_DEFINITION(ptVaultNode, findNode, args)
{
PyObject* nodeObj = NULL;
if (!PyArg_ParseTuple(args, "O", &nodeObj))
{
PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
PYTHON_RETURN_ERROR;
}
if (!pyVaultNode::Check(nodeObj))
{
PyErr_SetString(PyExc_TypeError, "findNode expects a ptVaultNode");
PYTHON_RETURN_ERROR;
}
pyVaultNode* node = pyVaultNode::ConvertFrom(nodeObj);
return self->fThis->FindNode(node);
}
PYTHON_METHOD_DEFINITION(ptVaultNode, addNode, args)
{
PyObject* nodeObj = NULL;
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "O|Ol", &nodeObj, &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "addNode expects a ptVaultNode, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyVaultNode::Check(nodeObj))
{
PyErr_SetString(PyExc_TypeError, "addNode expects a ptVaultNode, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
pyVaultNode* node = pyVaultNode::ConvertFrom(nodeObj);
return self->fThis->AddNode(node, cb, cbContext);
}
PYTHON_METHOD_DEFINITION(ptVaultNode, linkToNode, args)
{
int nodeID;
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "i|Ol", &nodeID, &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "linkToNode expects an int, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->LinkToNode(nodeID, cb, cbContext);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, removeNode, args)
{
PyObject* nodeObj = NULL;
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "O|Ol", &nodeObj, &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "removeNode expects a ptVaultNode, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
if (!pyVaultNode::Check(nodeObj))
{
PyErr_SetString(PyExc_TypeError, "removeNode expects a ptVaultNode, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
pyVaultNode* node = pyVaultNode::ConvertFrom(nodeObj);
PYTHON_RETURN_BOOL(self->fThis->RemoveNode(*node, cb, cbContext));
}
PYTHON_METHOD_DEFINITION(ptVaultNode, save, args)
{
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "|Ol", &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "save expects an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->Save(cb, cbContext);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, saveAll, args)
{
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "|Ol", &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "saveAll expects an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SaveAll(cb, cbContext);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, forceSave)
{
self->fThis->ForceSave();
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptVaultNode, sendTo, args)
{
unsigned long destNodeID;
PyObject* cb = NULL;
unsigned long cbContext = 0;
if (!PyArg_ParseTuple(args, "l|Ol", &destNodeID, &cb, &cbContext))
{
PyErr_SetString(PyExc_TypeError, "sendTo expects an unsigned long, and an optional object and unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SendTo(destNodeID, cb, cbContext);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToFolderNode)
{
return self->fThis->UpcastToFolderNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToPlayerInfoListNode)
{
return self->fThis->UpcastToPlayerInfoListNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToImageNode)
{
return self->fThis->UpcastToImageNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToTextNoteNode)
{
return self->fThis->UpcastToTextNoteNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToAgeLinkNode)
{
return self->fThis->UpcastToAgeLinkNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToChronicleNode)
{
return self->fThis->UpcastToChronicleNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToPlayerInfoNode)
{
return self->fThis->UpcastToPlayerInfoNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToMarkerGameNode)
{
return self->fThis->UpcastToMarkerGameNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToAgeInfoNode)
{
return self->fThis->UpcastToAgeInfoNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToAgeInfoListNode)
{
return self->fThis->UpcastToAgeInfoListNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToSDLNode)
{
return self->fThis->UpcastToSDLNode();
}
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToPlayerNode)
{
return self->fThis->UpcastToPlayerNode();
}
#ifndef BUILDING_PYPLASMA
PYTHON_METHOD_DEFINITION_NOARGS(ptVaultNode, upcastToSystemNode)
{
return self->fThis->UpcastToSystemNode();
}
#endif
PYTHON_START_METHODS_TABLE(ptVaultNode)
PYTHON_METHOD_NOARGS(ptVaultNode, getID, "Returns the unique ID of this ptVaultNode."),
PYTHON_METHOD_NOARGS(ptVaultNode, getType, "Returns the type of ptVaultNode this is.\n"
"See PlasmaVaultTypes.py"),
PYTHON_METHOD_NOARGS(ptVaultNode, getOwnerNodeID, "Returns the node ID of the owner of this node"),
PYTHON_METHOD_NOARGS(ptVaultNode, getOwnerNode, "Returns a ptVaultNode of the owner of this node"),
PYTHON_METHOD_NOARGS(ptVaultNode, getModifyTime, "Returns the modified time of this node, that is useable by python's time library."),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreatorNodeID, "Returns the creator's node ID"),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreatorNode, "Returns the creator's node"),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreateTime, "Returns the when this node was created, that is useable by python's time library."),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreateAgeTime, "Returns the time in the Age that the node was created...(?)"),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreateAgeName, "Returns the name of the Age where this node was created."),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreateAgeGuid, "Returns the guid as a string of the Age where this node was created."),
PYTHON_METHOD_NOARGS(ptVaultNode, getCreateAgeCoords, "Returns the location in the Age where this node was created."),
PYTHON_METHOD_NOARGS(ptVaultNode, getChildNodeRefList, "Returns a list of ptVaultNodeRef that are the children of this node."),
PYTHON_METHOD_NOARGS(ptVaultNode, getChildNodeCount, "Returns how many children this node has."),
PYTHON_METHOD_NOARGS(ptVaultNode, getClientID, "Returns the client's ID."),
PYTHON_METHOD(ptVaultNode, setID, "Params: id\nSets ID of this ptVaultNode."),
PYTHON_METHOD(ptVaultNode, setType, "Params: type\nSet the type of ptVaultNode this is."),
PYTHON_METHOD(ptVaultNode, setOwnerNodeID, "Params: id\nSet node ID of the owner of this node"),
PYTHON_METHOD(ptVaultNode, setCreatorNodeID, "Params: id\nSet creator's node ID"),
PYTHON_METHOD(ptVaultNode, setCreateAgeName, "Params: name\nSet name of the Age where this node was created."),
PYTHON_METHOD(ptVaultNode, setCreateAgeGuid, "Params: guid\nSet guid as a string of the Age where this node was created."),
PYTHON_BASIC_METHOD(ptVaultNode, removeAllNodes, "Removes all the child nodes on this node."),
PYTHON_METHOD(ptVaultNode, hasNode, "Params: id\nReturns true if node if a child node"),
PYTHON_METHOD(ptVaultNode, getNode, "Params: id\nReturns ptVaultNodeRef if is a child node, or None"),
PYTHON_METHOD(ptVaultNode, findNode, "Params: templateNode\nReturns ptVaultNode if child node found matching template, or None"),
PYTHON_METHOD(ptVaultNode, addNode, "Params: node,cb=None,cbContext=0\nAdds 'node'(ptVaultNode) as a child to this node."),
PYTHON_METHOD(ptVaultNode, linkToNode, "Params: nodeID,cb=None,cbContext=0\nAdds a link to the node designated by nodeID"),
PYTHON_METHOD(ptVaultNode, removeNode, "Params: node,cb=None,cbContext=0\nRemoves the child 'node'(ptVaultNode) from this node."),
PYTHON_METHOD(ptVaultNode, save, "Params: cb=None,cbContext=0\nSave the changes made to this node."),
PYTHON_METHOD(ptVaultNode, saveAll, "Params: cb=None,cbContext=0\nSaves this node and all its children nodes."),
PYTHON_METHOD_NOARGS(ptVaultNode, forceSave, "Force the current node to save immediately"),
PYTHON_METHOD(ptVaultNode, sendTo, "Params: destID,cb=None,cbContext=0\nSend this node to inbox at 'destID'"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToFolderNode, "Returns this ptVaultNode as ptVaultFolderNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToPlayerInfoListNode, "Returns this ptVaultNode as ptVaultPlayerInfoListNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToImageNode, "Returns this ptVaultNode as ptVaultImageNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToTextNoteNode, "Returns this ptVaultNode as ptVaultTextNoteNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToAgeLinkNode, "Returns this ptVaultNode as ptVaultAgeLinkNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToChronicleNode, "Returns this ptVaultNode as ptVaultChronicleNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToPlayerInfoNode, "Returns this ptVaultNode as ptVaultPlayerInfoNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToMarkerGameNode, "Returns this ptVaultNode as ptVaultMarkerNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToAgeInfoNode, "Returns this ptVaultNode as ptVaultAgeInfoNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToAgeInfoListNode, "Returns this ptVaultNode as ptVaultAgeInfoListNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToSDLNode, "Returns this ptVaultNode as a ptVaultSDLNode"),
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToPlayerNode, "Returns this ptVaultNode as a ptVaultPlayerNode"),
#ifndef BUILDING_PYPLASMA
PYTHON_METHOD_NOARGS(ptVaultNode, upcastToSystemNode, "Returns this ptVaultNode as a ptVaultSystemNode"),
#endif
PYTHON_END_METHODS_TABLE;
// Type structure definition
#define ptVaultNode_COMPARE PYTHON_NO_COMPARE
#define ptVaultNode_AS_NUMBER PYTHON_NO_AS_NUMBER
#define ptVaultNode_AS_SEQUENCE PYTHON_NO_AS_SEQUENCE
#define ptVaultNode_AS_MAPPING PYTHON_NO_AS_MAPPING
#define ptVaultNode_STR PYTHON_NO_STR
#define ptVaultNode_RICH_COMPARE PYTHON_DEFAULT_RICH_COMPARE(ptVaultNode)
#define ptVaultNode_GETSET PYTHON_NO_GETSET
#define ptVaultNode_BASE PYTHON_NO_BASE
PLASMA_CUSTOM_TYPE(ptVaultNode, "Vault node class");
PYTHON_EXPOSE_TYPE_DEFINITION(ptVaultNode, pyVaultNode);
// required functions for PyObject interoperability
PyObject *pyVaultNode::New(RelVaultNode* nfsNode)
{
ptVaultNode *newObj = (ptVaultNode*)ptVaultNode_type.tp_new(&ptVaultNode_type, NULL, NULL);
if (newObj->fThis->fNode)
newObj->fThis->fNode->DecRef();
newObj->fThis->fNode = nfsNode;
if (newObj->fThis->fNode)
newObj->fThis->fNode->IncRef();
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptVaultNode, pyVaultNode)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptVaultNode, pyVaultNode)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyVaultNode::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptVaultNode);
PYTHON_CLASS_IMPORT_END(m);
}