FunctionWrap.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "FunctionWrap.h"
#ifndef BOOST_DEFECT

#include <vector>

using std::string;
using std::vector;

using namespace boost::python;

namespace hippodraw {
  namespace Python {
    void
    export_FunctionBase ()
    {
      class_ < FunctionWrap, std::auto_ptr < FunctionWrap> >
        ( "FunctionBase",
          "The base class for raw functions.   FunctionBase objects need to\n"
          "wrapped with Function objects to be displayed.   FunctionBase\n"
          "can be derived from and cloned so they can be added to the\n"
          "FunctionFactory.",
          init < const FunctionBase & >
          ( "FunctionBase () -> FunctionBase\n"
            "FunctinBase ( FunctionBase ) -> FunctionBase\n"
            "\n"
            "Constructors of the FuncitonBase object.\n" ) )

        .def ( init <> () )

        .def ( init < const FunctionWrap & > () )

        .def ( "initialize", &FunctionWrap::initialize,
               "initialize () -> None\n"
               "\n"
               "Initializes the function parameter values and the names.\n"
               "The number of parameters is taken from the number of names." )

        .def ( "name", &FunctionBase::name,
               return_value_policy < copy_const_reference > (),
               "name () -> string\n"
               "\n"
               "Returns the name of the function." )

        .def ( "setName", &FunctionWrap::setName,
               "setName ( string ) -> None\n"
               "\n"
               "Sets the name of the function." )

        .def ( "parmNames",
               &FunctionBase::parmNames,
               return_value_policy < copy_const_reference > (),
               "parmNames () -> sequence\n"
               "\n"
               "Returns the names of the parameters" )

        .def ( "setParmNames",
               &FunctionWrap::setParmNames,
               "setParmNames ( sequence ) -> None\n"
               "\n"
               "Sets the parameter names and resizes the parameters" )

        .def ( "setParameters", 
               ( void ( FunctionBase::* ) // function pointer cast
               ( const std::vector < double > & ) )  // function signature
               &FunctionBase::setParameters,
               "setParameters ( sequence ) -> None\n"
               "\n"
               "Sets the values of the parameters." )

        .def ( "getParameters", &FunctionBase::getParameters,
               return_value_policy < copy_const_reference > (),
               "getParameters () -> sequence\n"
               "\n"
               "Returns the current function parameter values." )

        ;
    }
  }
}

FunctionWrap::
FunctionWrap ( )
  : FunctionBase ()
{
}

FunctionWrap::
FunctionWrap ( const FunctionBase & base )
  : FunctionBase ( base )//,
{
}

FunctionWrap::
FunctionWrap ( const FunctionWrap & wrap )
  : FunctionBase ( wrap )
{
}

FunctionWrap::
~FunctionWrap ()
{
//   PyGILState_STATE state = PyGILState_Ensure ();

//   extract<std::auto_ptr<FunctionWrap>&> x(get_owner(this));
//   if ( x.check() ) x().release();

//   PyGILState_Release ( state );
}

template <class T>
object
FunctionWrap::
get_owner(T* me) const
{
      // Use secret interface to get the Python object
      // that owns *this.  I guess I will have to make that
      // interface public. -- Dave Abrahams
      return
object ( handle<> ( borrowed ( detail::wrapper_base_::get_owner(*this))));
}


FunctionBase *
FunctionWrap::
clone () const
{
#ifndef HAVE_OLD_PYTHON
  PyGILState_STATE state = PyGILState_Ensure ();
  object py_result;

  if (override clone = this->get_override("clone"))
    {
      // The Python class author overrode clone; do
      // whatever she says
      py_result = clone();
    }
  else
    {
      FunctionWrap * t = const_cast < FunctionWrap * > ( this );
      object self = get_owner ( t );

      // Find its most-derived Python class
      object my_class = self.attr("__class__");

      // call the copy ctor through Python.
      py_result = my_class ( self );
    }
  FunctionWrap* result = extract<FunctionWrap*>(py_result);

  // Make the C++ result control the destiny of the Python result.
  result->invert_ownership = py_result;
  PyGILState_Release ( state );

  return result;
#else // old Python
  return 0;
#endif
}

void
FunctionWrap::
setName ( const std::string & name )
{
  FunctionBase::setName ( name.c_str() );
}

void
FunctionWrap::
setParmNames ( const std::vector < std::string > & names )
{
  m_parm_names = names;
  resize ();
}

double
FunctionWrap::
derivByParm ( int i , double x ) const
{
#ifndef HAVE_OLD_PYTHON
  double value = 0.;
  PyGILState_STATE state = PyGILState_Ensure ();

  FunctionWrap * t = const_cast < FunctionWrap * > ( this );
  object self = get_owner ( t );

  try {
    value = call_method < double, int, double > 
      ( self.ptr(), "derivByParm", i, x );
  }  catch ( ... ) {
    value = 0.;
  }

  PyGILState_Release ( state );

  return value;
#else // old Python
  return 0;
#endif
}

void
FunctionWrap::
initialize ()
{
#ifndef HAVE_OLD_PYTHON
  PyGILState_STATE state = PyGILState_Ensure ();

  FunctionWrap * t = const_cast < FunctionWrap * > ( this );
  object self = get_owner ( t );
  call_method < void > ( self.ptr(), "initialize" );
  resize ();

  PyGILState_Release ( state );
#endif
}

double
FunctionWrap::
operator () ( double x ) const
{
#ifndef HAVE_OLD_PYTHON
  PyGILState_STATE state = PyGILState_Ensure ();
  FunctionWrap * t = const_cast < FunctionWrap * > ( this );
  object self = get_owner ( t );
  double value = call_method < double, double > ( self.ptr(), "valueAt", x );
  PyGILState_Release ( state );

  return value;
#else // old Python
  return 0;
#endif
}

double
FunctionWrap::
operator () ( const std::vector < double > & x ) const
{
#ifndef HAVE_OLD_PYTHON
  PyGILState_STATE state = PyGILState_Ensure ();
  FunctionWrap * t = const_cast < FunctionWrap * > ( this );
  object self = get_owner ( t );
  double value 
    = call_method < double, double, double > 
    ( self.ptr(), "valueAt", x[0], x[1] );
  PyGILState_Release ( state );

  return value;
#else // old Python
  return 0;
#endif
}

void
FunctionWrap::
initialParameters ( const FunctionHelper * )
{
}

#endif // BOOST_DEFECT

---