python_init.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn 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.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "simlpy/interpreter_defs.h"
#include "simlpy/interpreter_hooks.h"

#include "EpidemicApp.h"

#include "mobility/MobileNode.h"
#include "mobility/WirelessLink.h"
#include "dtn/SpaceAvailCustody.h"
#include "pydtn/parsers.h"
#include "mobility/parsers.h"
#include "simlpy/Clock.h"

#ifndef PyMODINIT_FUNC
#define PyMODINIT_FUNC extern "C" void
#endif


//======================================================================
// Methods callable from python
// ----------------------------
//
// There's only one method to call from python, attach().  We define
// two things here related to this method.  First, we define a
// documentation string, called epidemic_attach_doc.  This is what
// will be displayed when we type "help(attach)" at the interactive
// prompt.
//
// The second thing we define is the actual C++ function that will be
// called when we invoke attach() in python.  The function's name is
// epidemic_attach.
//
// Using these two definitions, we then create the structure that will
// bind the C++ function and docstring to the python function name.
//======================================================================


static char epidemic_attach_doc[] = "Add an application instance to a node.\n\
   \n\
   Calling syntax:\n\
   \n\
   pydtn.mobility.basicepidemic.attach(<n>,<l>)\n\
   \n\
      <n> is a mobile node to which we want to add an instance.\n\
      <l> is the wireless link for the node.\n\
   \n\
   In general, this will be called automatically at node creation by\n\
   pydtn.mobility.node()\n";

static PyObject*
epidemic_attach( PyObject* self, PyObject* args )
{
   // Check the arguments.  The first check is guaranteed to succeed
   // if we've registered the method correctly with METH_VARARGS.
   if ( ! PyTuple_Check( args ) )
   {
      PyErr_SetString(PyExc_TypeError,"attach expects a list of arguments");
      return 0;
   }
   if ( PyTuple_Size( args ) < 2 )
   {
      PyErr_SetString(PyExc_TypeError,
                      "attach expects two arguments");
      return 0;
   }

   // The arguments should be a tuple of the form (node,link).  We
   // could have used build_arglist() and clean_arglist() from
   // simlpy/interpreter_hooks.h here.  This lower-level interface
   // requires no management of reference counts.
   Mobility::MobileNode* mn = Mobility::parse_mn( PyTuple_GetItem(args,0) );
   if ( 0 == mn ) return 0;

   Mobility::WirelessLink* wl = Mobility::parse_wl( PyTuple_GetItem(args,1) );
   if ( 0 == wl ) return 0;

   // Construct the protocol instance, which is initialized with the
   // wireless link and the default bundle lifetime.
   BasicEpidemic::EpidemicApp* ma =
      new BasicEpidemic::EpidemicApp( mn,
                                      &(wl->link()),
                                      mn->bundleLifetime().tv );

   // Attach the protocol to the mobile node.  This will also set the
   // forwarding policy, when the node reciprocally sets itself as the
   // protocol's owner.
   mn->addMobileApp(ma);

   // Make sure there's a custody policy registered with the node.
   if ( ! mn->node().hasCustodyPolicy() )
   {
      // Use SpaceAvailCustody as a default, if nothing has been configured.
      mn->node().setCustodyPolicy( new DTN::SpaceAvailCustody(&(mn->node())) );
   }

   // We're not returning anything meaningful, but we have to return
   // something, so we use the python None object.  It's a
   // pre-existing object, so we don't have to create it, but we do
   // need to tell python that there's another reference to it now.
   Py_INCREF(Py_None);
   return Py_None;
}

static PyMethodDef ExampleMethods[] =
{
   {"attach",epidemic_attach,METH_VARARGS,epidemic_attach_doc},
   {0,0,0,0} // sentinel
};

PyMODINIT_FUNC
init_basicepidemic(void)
{
   (void) Py_InitModule("_basicepidemic",ExampleMethods);
}

---