PyFitsController.cxx

Go to the documentation of this file.

#ifdef _MSC_VER
// nonstandard extension used 'extern' before...
# pragma warning(disable:4231)  

// needs to have dll-interface used by client
# pragma warning(disable:4251)  

// non dll-interface struct
# pragma warning(disable:4275)  

// 'int' : forcing value to bool 'true' or 'false' (performance warning)
# pragma warning(disable:4800)  
#endif

#include "PyFitsController.h"

#include "PyDataSource.h"

#include "fits/FitsController.h"
#include "fits/FitsNTuple.h"

#include "datasrcs/DataSourceException.h"

#include <boost/python.hpp>

using std::vector;
using namespace boost::python;

namespace hippodraw {
namespace Python {

void 
export_FitsController()
{
  class_ < PyFitsController, bases<>,
    PyFitsController, boost::noncopyable >
    ( "FitsController",
      "A class for creation of DataSource objects from a FITS file.",
      no_init )

    .def ( "instance",  &PyFitsController::instance,
           return_value_policy < reference_existing_object >  (),
           "instance () -> FitsController\n"
           "\n"
           "Returns the single instance of the controller." )

    .staticmethod( "instance" )

    .def ( "getNTupleNames",
           &PyFitsController::getNTupleNames,
           return_value_policy < copy_const_reference > (),
           "getNTupleNames ( string ) -> sequence\n"
           "\n"
           "Returns the names of the HDU data source objects in the file." )

    .def ( "createNTuple",
           &PyFitsController::createNTuple,
           return_value_policy < reference_existing_object >  (),
           "createNTuple ( string, string ) -> FitsNTuple\n"
           "\n"
           "Creates FitsNTuple from the named file with key name." )

    .def ( "createDataArray",
           &PyFitsController::createDataArray,
           return_value_policy < reference_existing_object >  (),
           "createDataArray ( string, string ) -> DataArray\n"
           "\n"
           "Creates DataArray from a file with key name" )
    ;

}

} // namespace Python
} // namespace hippodraw

FitsController   * PyFitsController::m_instance = 0;
PyFitsController * PyFitsController::s_instance = 0;


PyFitsController::
PyFitsController()
{
}

PyFitsController *
PyFitsController::
instance ()
{
  if ( s_instance == 0 ) {
    s_instance = new PyFitsController ();
    m_instance = FitsController::instance ();
  }

  return s_instance;
}

FitsNTuple *
PyFitsController::
createNTuple ( const std::string & filename, const std::string & hduname )
{
  FitsNTuple * ftuple = 0;

  try {
    DataSource * ntuple = m_instance -> createNTuple ( filename, hduname );
    ftuple = dynamic_cast < FitsNTuple * > ( ntuple );
  }
  catch ( const DataSourceException & e ) {
    throw e;
  }
  return ftuple;
}

PyDataSource *
PyFitsController::
createDataArray ( const std::string & filename, const std::string & hduname )
{
  FitsNTuple * tuple = createNTuple ( filename, hduname );
  PyDataSource * ds = new PyDataSource ( "FitsNTuple", tuple );

  return ds;
}

const std::vector < std::string > &
PyFitsController::
getNTupleNames ( const std::string & filename )
{
  try {
    const std::vector< std::string > & names 
      =  m_instance -> getNTupleNames ( filename );
    return names;
  }
  catch ( const DataSourceException & e ) {
    throw e;
  }
  static const std::vector < std::string > names;

  return names;
}

---