PyObject * swig_int::__pow__( PyObject * obj1 ) {
PyObject * ret = NULL ;
void * argp2 ;
if ( units.compare("1")) {
PyErr_SetString(PyExc_TypeError,"Both arguments must be unitless. Cannot create new unit-ed type.");
return NULL ;
}
if ( PyFloat_Check(obj1) ) {
swig_double * result = new swig_double() ;
result->value = pow(value , PyFloat_AsDouble(obj1)) ;
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_double *"), SWIG_POINTER_OWN);
} else if (SWIG_IsOK(SWIG_ConvertPtr(obj1, &argp2,SWIG_TypeQuery("swig_int *"), 0 ))) {
swig_int * temp_m = reinterpret_cast< swig_int * >(argp2) ;
swig_int * result = new swig_int() ;
if ( !temp_m->units.compare("1")) {
result->value = (long long)(pow(value , temp_m->value)) ;
} else {
PyErr_SetString(PyExc_TypeError,"Both arguments must be unitless. Cannot create new unit-ed type.");
return NULL ;
}
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_int *"), SWIG_POINTER_OWN);
} else if (SWIG_IsOK(SWIG_ConvertPtr(obj1, &argp2,SWIG_TypeQuery("swig_double *"), 0 ))) {
swig_double * result = new swig_double() ;
swig_double * temp_m = reinterpret_cast< swig_double * >(argp2) ;
if ( !temp_m->units.compare("1")) {
result->value = pow(value , temp_m->value) ;
} else {
PyErr_SetString(PyExc_TypeError,"Both arguments must be unitless. Cannot create new unit-ed type.");
return NULL ;
}
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_double *"), SWIG_POINTER_OWN);
} else if ( PyInt_Check(obj1) ) {
swig_int * result = new swig_int() ;
int power = PyInt_AsLong(obj1) ;
result->value = (long long)(pow(value , power)) ;
result->units = units ;
for ( int ii = 1 ; ii < power ; ii++ ) {
result->units = result->units + "*(" + units + ")";
}
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_int *"), SWIG_POINTER_OWN);
}
return ret ;
}
/********************************************************************\
* gnc_copy_trans *
* returns a scheme representation of a transaction. If the *
* transaction is NULL, SCM_UNDEFINED is returned. *
* *
* Args: trans - the transaction to copy *
* use_cut_semantics - if TRUE, copy is for a 'cut' operation *
* Returns: SCM representation of transaction or SCM_UNDEFINED *
\********************************************************************/
SCM
gnc_copy_trans(Transaction *trans, gboolean use_cut_semantics)
{
static swig_type_info *trans_type = NULL;
SCM func;
SCM arg;
if (trans == NULL)
return SCM_UNDEFINED;
func = scm_c_eval_string("gnc:transaction->transaction-scm");
if (!scm_is_procedure(func))
return SCM_UNDEFINED;
if (!trans_type)
trans_type = SWIG_TypeQuery("_p_Transaction");
arg = SWIG_NewPointerObj(trans, trans_type, 0);
return scm_call_2(func, arg, SCM_BOOL(use_cut_semantics));
}
/********************************************************************\
* gnc_copy_split *
* returns a scheme representation of a split. If the split is *
* NULL, SCM_UNDEFINED is returned. *
* *
* Args: split - the split to copy *
* use_cut_semantics - if TRUE, copy is for a 'cut' operation *
* Returns: SCM representation of split or SCM_UNDEFINED *
\********************************************************************/
SCM
gnc_copy_split(Split *split, gboolean use_cut_semantics)
{
static swig_type_info *split_type = NULL;
SCM func;
SCM arg;
if (split == NULL)
return SCM_UNDEFINED;
func = scm_c_eval_string("gnc:split->split-scm");
if (!scm_is_procedure(func))
return SCM_UNDEFINED;
if (!split_type)
split_type = SWIG_TypeQuery("_p_Split");
arg = SWIG_NewPointerObj(split, split_type, 0);
return scm_call_2(func, arg, SCM_BOOL(use_cut_semantics));
}
void
gnc_prices_dialog_get_quotes_clicked (GtkWidget *widget, gpointer data)
{
PricesDialog *pdb_dialog = data;
SCM quotes_func;
SCM book_scm;
SCM scm_window;
ENTER(" ");
quotes_func = scm_c_eval_string ("gnc:book-add-quotes");
if (!scm_is_procedure (quotes_func))
{
LEAVE(" no procedure");
return;
}
book_scm = gnc_book_to_scm (pdb_dialog->book);
if (scm_is_true (scm_not (book_scm)))
{
LEAVE("no book");
return;
}
scm_window = SWIG_NewPointerObj(pdb_dialog->dialog,
SWIG_TypeQuery("_p_GtkWidget"), 0);
gnc_set_busy_cursor (NULL, TRUE);
scm_call_2 (quotes_func, scm_window, book_scm);
gnc_unset_busy_cursor (NULL);
/* Without this, the summary bar on the accounts tab
* won't reflect the new prices (bug #522095). */
gnc_gui_refresh_all ();
LEAVE(" ");
}
/********************************************************************\
* gnc_copy_split_scm_onto_split *
* copies a scheme representation of a split onto an actual split.*
* *
* Args: split_scm - the scheme representation of a split *
* split - the split to copy onto *
* Returns: Nothing *
\********************************************************************/
void
gnc_copy_split_scm_onto_split(SCM split_scm, Split *split,
QofBook * book)
{
static swig_type_info *split_type = NULL;
SCM result;
SCM func;
SCM arg;
if (split_scm == SCM_UNDEFINED)
return;
if (split == NULL)
return;
g_return_if_fail (book);
func = scm_c_eval_string("gnc:split-scm?");
if (!scm_is_procedure(func))
return;
result = scm_call_1(func, split_scm);
if (!scm_is_true(result))
return;
func = scm_c_eval_string("gnc:split-scm-onto-split");
if (!scm_is_procedure(func))
return;
if (!split_type)
split_type = SWIG_TypeQuery("_p_Split");
arg = SWIG_NewPointerObj(split, split_type, 0);
scm_call_3(func, split_scm, arg, gnc_book_to_scm (book));
}
Teuchos::RCP< const Epetra_MultiVector >
getConstEpetraMultiVectorObjectAttr(PyObject * object,
CONST char * name)
{
static swig_type_info * swig_EMV_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_MultiVector > *");
void * argp;
PyObject * value = PyObject_GetAttrString(object, name);
int newmem = 0;
if (!SWIG_CheckState(SWIG_Python_ConvertPtrAndOwn(value, &argp, swig_EMV_ptr, 0, &newmem)))
{
PyErr_Format(PyExc_TypeError,
"Attribute '%s' is not of type Epetra.MultiVector",
name);
Py_DECREF(value);
throw PythonException();
}
Teuchos::RCP< const Epetra_MultiVector > result =
*reinterpret_cast< Teuchos::RCP< const Epetra_MultiVector > * >(argp);
if (newmem)
delete reinterpret_cast< Teuchos::RCP< const Epetra_MultiVector > * >(argp);
Py_DECREF(value);
return result;
}
PyObject * swig_int::__mod__( PyObject * obj1 ) {
PyObject * ret = NULL ;
void * argp2 ;
if ( PyFloat_Check(obj1) ) {
swig_double * result = new swig_double() ;
result->value = fmod(value , PyFloat_AsDouble(obj1)) ;
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_double *"), SWIG_POINTER_OWN);
} else if (SWIG_IsOK(SWIG_ConvertPtr(obj1, &argp2,SWIG_TypeQuery("swig_int *"), 0 ))) {
swig_int * result = new swig_int() ;
swig_int * temp_m = reinterpret_cast< swig_int * >(argp2) ;
if ( !temp_m->units.compare("1")) {
result->value = value % temp_m->value ;
} else {
PyErr_SetString(PyExc_TypeError,"Divisor must be unitless. Cannot create new unit-ed type.");
return NULL ;
}
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_int *"), SWIG_POINTER_OWN);
} else if (SWIG_IsOK(SWIG_ConvertPtr(obj1, &argp2,SWIG_TypeQuery("swig_double *"), 0 ))) {
swig_double * result = new swig_double() ;
swig_double * temp_m = reinterpret_cast< swig_double * >(argp2) ;
if ( !temp_m->units.compare("1")) {
result->value = fmod( value , temp_m->value) ;
} else {
PyErr_SetString(PyExc_TypeError,"Divisor must be unitless. Cannot create new unit-ed type.");
return NULL ;
}
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_double *"), SWIG_POINTER_OWN);
} else if ( PyInt_Check(obj1) ) {
swig_int * result = new swig_int() ;
result->value = value % PyInt_AsLong(obj1) ;
result->units = units ;
ret = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIG_TypeQuery("swig_int *"), SWIG_POINTER_OWN);
}
return ret ;
}
/********************************************************************\
* gnc_copy_trans_scm_onto_trans_swap_accounts *
* copies a scheme representation of a transaction onto *
* an actual transaction. If guid_1 and guid_2 are not NULL, *
* the account guids of the splits are swapped accordingly. *
* *
* Args: trans_scm - the scheme representation of a transaction *
* trans - the transaction to copy onto *
* guid_1 - account guid to swap with guid_2 *
* guid_2 - account guid to swap with guid_1 *
* do_commit - whether to commit the edits *
* Returns: Nothing *
\********************************************************************/
void
gnc_copy_trans_scm_onto_trans_swap_accounts(SCM trans_scm,
Transaction *trans,
const GncGUID *guid_1,
const GncGUID *guid_2,
gboolean do_commit,
QofBook *book)
{
static swig_type_info *trans_type = NULL;
SCM result;
SCM func;
SCM arg;
if (trans_scm == SCM_UNDEFINED)
return;
if (trans == NULL)
return;
g_return_if_fail (book);
func = scm_c_eval_string("gnc:transaction-scm?");
if (!scm_is_procedure(func))
return;
result = scm_call_1(func, trans_scm);
if (!scm_is_true(result))
return;
func = scm_c_eval_string("gnc:transaction-scm-onto-transaction");
if (!scm_is_procedure(func))
return;
if (!trans_type)
trans_type = SWIG_TypeQuery("_p_Transaction");
arg = SWIG_NewPointerObj(trans, trans_type, 0);
if ((guid_1 == NULL) || (guid_2 == NULL))
{
SCM args = SCM_EOL;
SCM commit;
commit = SCM_BOOL(do_commit);
args = scm_cons(gnc_book_to_scm (book), args);
args = scm_cons(commit, args);
args = scm_cons(SCM_EOL, args);
args = scm_cons(arg, args);
args = scm_cons(trans_scm, args);
scm_apply(func, args, SCM_EOL);
}
else
{
gchar guidstr[GUID_ENCODING_LENGTH+1];
SCM from, to;
SCM map = SCM_EOL;
SCM args = SCM_EOL;
SCM commit;
args = scm_cons(gnc_book_to_scm (book), args);
commit = SCM_BOOL(do_commit);
args = scm_cons(commit, args);
guid_to_string_buff(guid_1, guidstr);
from = scm_from_utf8_string(guidstr);
guid_to_string_buff(guid_2, guidstr);
to = scm_from_utf8_string(guidstr);
map = scm_cons(scm_cons(from, to), map);
map = scm_cons(scm_cons(to, from), map);
args = scm_cons(map, args);
args = scm_cons(arg, args);
args = scm_cons(trans_scm, args);
scm_apply(func, args, SCM_EOL);
}
}
GtkWidget *
gnc_column_view_edit_options(SCM options, SCM view)
{
SCM get_editor = scm_c_eval_string("gnc:report-editor-widget");
SCM ptr;
GtkWidget * editor;
GtkListStore *store;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *selection;
ptr = scm_call_1(get_editor, view);
if (ptr != SCM_BOOL_F)
{
#define FUNC_NAME "gtk_window_present"
GtkWindow * w = SWIG_MustGetPtr(ptr, SWIG_TypeQuery("_p_GtkWidget"), 1, 0);
gtk_window_present(w);
#undef FUNC_NAME
return NULL;
}
else
{
gnc_column_view_edit * r = g_new0(gnc_column_view_edit, 1);
GladeXML *xml;
r->optwin = gnc_options_dialog_new(NULL);
/* Hide the generic dialog page list. */
{
GtkWidget *dialog, *page_list;
dialog = gnc_options_dialog_widget(r->optwin);
page_list = gnc_glade_lookup_widget (dialog, "page_list");
gtk_widget_hide(page_list);
}
xml = gnc_glade_xml_new ("report.glade", "view_contents_table");
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_add_cb",
G_CALLBACK (gnc_column_view_edit_add_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_remove_cb",
G_CALLBACK (gnc_column_view_edit_remove_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_edit_column_view_move_up_cb",
G_CALLBACK (gnc_edit_column_view_move_up_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_edit_column_view_move_down_cb",
G_CALLBACK (gnc_edit_column_view_move_down_cb), r);
glade_xml_signal_connect_data
(xml, "gnc_column_view_edit_size_cb",
G_CALLBACK (gnc_column_view_edit_size_cb), r);
editor = glade_xml_get_widget (xml, "view_contents_table");
r->available = GTK_TREE_VIEW (glade_xml_get_widget (xml, "available_view"));
r->contents = GTK_TREE_VIEW (glade_xml_get_widget (xml, "contents_view"));
r->options = options;
r->view = view;
r->available_selected = 0;
r->available_list = SCM_EOL;
r->contents_selected = 0;
r->contents_list = SCM_EOL;
r->odb = gnc_option_db_new(r->options);
gnc_options_dialog_build_contents(r->optwin, r->odb);
gtk_notebook_append_page(GTK_NOTEBOOK(gnc_options_dialog_notebook
(r->optwin)),
editor,
gtk_label_new(_("Contents")));
scm_gc_protect_object(r->options);
scm_gc_protect_object(r->view);
scm_gc_protect_object(r->available_list);
scm_gc_protect_object(r->contents_list);
/* Build the 'available' view */
store = gtk_list_store_new (NUM_AVAILABLE_COLS, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model(r->available, GTK_TREE_MODEL(store));
gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(store), AVAILABLE_COL_NAME, GTK_SORT_ASCENDING);
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes("", renderer,
"text", AVAILABLE_COL_NAME,
NULL);
gtk_tree_view_append_column(r->available, column);
selection = gtk_tree_view_get_selection(r->available);
g_signal_connect(selection, "changed",
G_CALLBACK(gnc_column_view_select_avail_cb), r);
/* Build the 'contents' view */
store = gtk_list_store_new (NUM_CONTENTS_COLS, G_TYPE_STRING, G_TYPE_INT,
G_TYPE_INT, G_TYPE_INT);
gtk_tree_view_set_model(r->contents, GTK_TREE_MODEL(store));
g_object_unref(store);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Report"), renderer,
"text", CONTENTS_COL_NAME,
NULL);
gtk_tree_view_append_column(r->contents, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Rows"), renderer,
"text", CONTENTS_COL_REPORT_ROWS,
NULL);
gtk_tree_view_append_column(r->contents, column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Cols"), renderer,
"text", CONTENTS_COL_REPORT_COLS,
NULL);
gtk_tree_view_append_column(r->contents, column);
selection = gtk_tree_view_get_selection(r->contents);
g_signal_connect(selection, "changed",
G_CALLBACK(gnc_column_view_select_contents_cb), r);
update_display_lists(r);
gnc_options_dialog_set_apply_cb(r->optwin,
gnc_column_view_edit_apply_cb, r);
gnc_options_dialog_set_close_cb(r->optwin,
gnc_column_view_edit_close_cb, r);
gtk_widget_show(gnc_options_dialog_widget(r->optwin));
return gnc_options_dialog_widget(r->optwin);
}
}
PyObject *
convertEpetraOperatorToPython(const Teuchos::RCP< const Epetra_Operator > *ceo)
{
// SWIG initialization
static swig_type_info *swig_EO_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_Operator >*");
// static swig_type_info *swig_EFCO_ptr =
// SWIG_TypeQuery("Teuchos::RCP< Epetra_FastCrsOperator >*");
static swig_type_info *swig_EIO_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_InvOperator >*");
static swig_type_info *swig_ERM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_RowMatrix >*");
static swig_type_info *swig_EBRM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_BasicRowMatrix >*");
static swig_type_info *swig_ECM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_CrsMatrix >*");
// static swig_type_info *swig_EMM_ptr =
// SWIG_TypeQuery("Teuchos::RCP< Epetra_MsrMatrix >*");
static swig_type_info *swig_EVM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_VbrMatrix >*");
static swig_type_info *swig_EVRM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_VbrRowMatrix >*");
static swig_type_info *swig_EFVM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_FEVbrMatrix >*");
static swig_type_info *swig_EFCM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_FECrsMatrix >*");
static swig_type_info *swig_EJM_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_JadMatrix >*");
//
// Cast const-ness away
Teuchos::RCP< Epetra_Operator > *eo = new
Teuchos::RCP< Epetra_Operator >(Teuchos::rcp_const_cast< Epetra_Operator >(*ceo));
//
// Attempt to downcast to Epetra_VbrMatrix
Teuchos::RCP< const Epetra_VbrRowMatrix > *evrm = new
Teuchos::RCP< const Epetra_VbrRowMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_VbrRowMatrix >(*eo));
if (evrm->is_null()) delete evrm;
else return SWIG_NewPointerObj((void*)evrm, swig_EVRM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_FEVbrMatrix
Teuchos::RCP< const Epetra_FEVbrMatrix > *efvm = new
Teuchos::RCP< const Epetra_FEVbrMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_FEVbrMatrix >(*eo));
if (efvm->is_null()) delete efvm;
else return SWIG_NewPointerObj((void*)efvm, swig_EFVM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_FECrsMatrix
Teuchos::RCP< const Epetra_FECrsMatrix > *efcm = new
Teuchos::RCP< const Epetra_FECrsMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_FECrsMatrix >(*eo));
if (efcm->is_null()) delete efcm;
else return SWIG_NewPointerObj((void*)efcm, swig_EFCM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_JadMatrix
Teuchos::RCP< const Epetra_JadMatrix > *ejm = new
Teuchos::RCP< const Epetra_JadMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_JadMatrix >(*eo));
if (ejm->is_null()) delete ejm;
else return SWIG_NewPointerObj((void*)ejm, swig_EJM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_BasicRowMatrix
Teuchos::RCP< const Epetra_BasicRowMatrix > *ebrm = new
Teuchos::RCP< const Epetra_BasicRowMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_BasicRowMatrix >(*eo));
if (ebrm->is_null()) delete ebrm;
else return SWIG_NewPointerObj((void*)ebrm, swig_EBRM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_CrsMatrix
Teuchos::RCP< const Epetra_CrsMatrix > *ecm = new
Teuchos::RCP< const Epetra_CrsMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_CrsMatrix >(*eo));
if (ecm->is_null()) delete ecm;
else return SWIG_NewPointerObj((void*)ecm, swig_ECM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_MsrMatrix
// Teuchos::RCP< const Epetra_MsrMatrix > *emm = new
// Teuchos::RCP< const Epetra_MsrMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_MsrMatrix >(*eo));
// if (emm->is_null()) delete emm;
// else return SWIG_NewPointerObj((void*)emm, swig_EMM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_VbrMatrix
Teuchos::RCP< const Epetra_VbrMatrix > *evm = new
Teuchos::RCP< const Epetra_VbrMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_VbrMatrix >(*eo));
if (evm->is_null()) delete evm;
else return SWIG_NewPointerObj((void*)evm, swig_EVM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_RowMatrix
Teuchos::RCP< const Epetra_RowMatrix > *erm = new
Teuchos::RCP< const Epetra_RowMatrix >(Teuchos::rcp_dynamic_cast< const Epetra_RowMatrix >(*eo));
if (erm->is_null()) delete erm;
else return SWIG_NewPointerObj((void*)erm, swig_ERM_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_InvOperator
Teuchos::RCP< const Epetra_InvOperator > *eio = new
Teuchos::RCP< const Epetra_InvOperator >(Teuchos::rcp_dynamic_cast< const Epetra_InvOperator >(*eo));
if (eio->is_null()) delete eio;
else return SWIG_NewPointerObj((void*)eio, swig_EIO_ptr, SWIG_POINTER_OWN);
//
// Attempt to downcast to Epetra_FastCrsOperator
// Teuchos::RCP< const Epetra_FastCrsOperator > *efco = new
// Teuchos::RCP< const Epetra_FastCrsOperator >(Teuchos::rcp_dynamic_cast< const Epetra_FastCrsOperator >(*eo));
// if (efco->is_null()) delete efco;
// else return SWIG_NewPointerObj((void*)efco, swig_EFCO_ptr, SWIG_POINTER_OWN);
//
// If downcast is not possible, return python Epetra_Operator
return SWIG_NewPointerObj((void*)eo, swig_EO_ptr, SWIG_POINTER_OWN);
}
Teuchos::RCP< Epetra_MultiVector > *
convertPythonToEpetraMultiVector(PyObject * pyobj)
{
// SWIG initialization
static swig_type_info * swig_EMV_ptr =
SWIG_TypeQuery("Teuchos::RCP< Epetra_MultiVector >*");
static swig_type_info * swig_DMDV_ptr =
SWIG_TypeQuery("Teuchos::RCP< Domi::MDVector<double> >*");
//
// Get the default communicator
const Teuchos::RCP< const Teuchos::Comm<int> > comm =
Teuchos::DefaultComm<int>::getComm();
//
// Result objects
void *argp = 0;
Teuchos::RCP< Epetra_MultiVector > * result = 0;
Teuchos::RCP< Epetra_MultiVector > emv_rcp;
Teuchos::RCP< Domi::MDVector<double> > dmdv_rcp;
int newmem = 0;
//
// Check if the Python object is a wrapped Epetra_MultiVector
int res = SWIG_ConvertPtrAndOwn(pyobj, &argp, swig_EMV_ptr, 0, &newmem);
if (SWIG_IsOK(res))
{
result =
reinterpret_cast< Teuchos::RCP< Epetra_MultiVector > * >(argp);
return result;
}
#ifdef HAVE_DOMI
//
// Check if the Python object is a wrapped Domi::MDVector<double>
newmem = 0;
res = SWIG_ConvertPtrAndOwn(pyobj, &argp, swig_DMDV_ptr, 0, &newmem);
if (SWIG_IsOK(res))
{
if (newmem & SWIG_CAST_NEW_MEMORY)
{
dmdv_rcp =
*reinterpret_cast< Teuchos::RCP< Domi::MDVector<double> > * >(argp);
delete reinterpret_cast< Teuchos::RCP< Domi::MDVector<double> > * >(argp);
//** result = &(dmdv_rcp->getEpetraMultiVectorView());
}
else
{
dmdv_rcp =
*reinterpret_cast< Teuchos::RCP< Domi::MDVector<double> > * >(argp);
//** result = &(dmdv_rcp->getEpetraMultiVectorView());
}
return result;
}
//
// Check if the Python object supports the DistArray Protocol
if (PyObject_HasAttrString(pyobj, "__distarray__"))
{
DistArrayProtocol dap(pyobj);
dmdv_rcp = convertToMDVector<double>(comm, dap);
//** result = &(dmdv_rcp->getEpetraMultiVectorView());
return result;
}
#endif
//
// Check if the environment is serial, and if so, check if the
// Python object is a NumPy array
if (comm->getSize() == 1)
{
if (PyArray_Check(pyobj))
{
//** result = new Teuchos::RCP< Epetra_NumPyMultiVector >(
//** new Epetra_NumPyMultiVector(pyobj));
return result;
}
}
//
// If we get to this point, then none of our known converters will
// work, so it is time to throw an exception.
PyErr_Format(PyExc_TypeError, "Could not convert argument of type '%s' to "
"an Epetra_MultiVector",
PyString_AsString(PyObject_Str(PyObject_Type(pyobj))));
throw PythonException();
}
