moosemodule.h File Reference

#include <string>

Include dependency graph for moosemodule.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_Field
struct	_Id
struct	_ObjId
struct	module_state

Macros
#define	ElementField_Check(v)   (Py_TYPE(v) == &moose_ElementField)
#define	ElementField_SubtypeCheck(v)   (PyType_IsSubtype(Py_TYPE(v), &moose_ElementField))
#define	GETSTATE(m)   (&_state)
#define	Id_Check(v)   (Py_TYPE(v) == &IdType)
#define	Id_SubtypeCheck(v)   (PyType_IsSubtype(Py_TYPE(v),&IdType))
#define	LookupField_Check(v)   (Py_TYPE(v) == &moose_LookupField)
#define	maxArgs   10
#define	minArgs   1
#define	O32_HOST_ORDER   (o32_host_order.value)
#define	ObjId_Check(v)   (Py_TYPE(v) == &ObjIdType)
#define	ObjId_SubtypeCheck(v)   (PyType_IsSubtype(Py_TYPE(v), &ObjIdType))
#define	RAISE_INVALID_ID(ret, msg)
#define	RAISE_TYPE_ERROR(ret, type)
#define	SET_LOOKUP_VALUE(TYPE)
#define	SHELLPTR   (reinterpret_cast<Shell*>(getShell(0, NULL).eref().data()))

Enumerations
enum	{ O32_LITTLE_ENDIAN = 0x03020100ul, O32_BIG_ENDIAN = 0x00010203ul, O32_PDP_ENDIAN = 0x01000302ul }

Functions
template<class A >
PyObject *	_set_vector_destFinfo (ObjId obj, string fieldName, PyObject *value, char vtypecode)
PyObject *	convert_and_set_tuple_entry (PyObject *tuple, unsigned int index, void *vptr, char typecode)
Id	create_Id_from_path (string path, unsigned int numData, unsigned int isGlobal, string type)
int	defineAllClasses (PyObject *module_dict)
int	defineClass (PyObject *module_dict, const Cinfo *cinfo)
int	defineDestFinfos (const Cinfo *cinfo)
int	defineElementFinfos (const Cinfo *cinfo)
int	defineLookupFinfos (const Cinfo *cinfo)
PyObject *	deleteObjId (ObjId obj)
const map< string, string > &	get_field_alias ()
map< string, vector < PyGetSetDef > > &	get_getsetdefs ()
map< string, PyTypeObject * > &	get_moose_classes ()
int	get_npy_typenum (const type_info &ctype)
template<typename KeyType , typename ValueType >
PyObject *	get_simple_lookupfield (ObjId oid, string fieldname, KeyType key, char vtypecode)
template<typename KeyType , typename ValueType >
PyObject *	get_vec_lookupfield (ObjId oid, string fieldname, KeyType key, char vtypecode)
PyTypeObject *	getBaseClass (PyObject *self)
vector< string >	getFieldNames (string className, string finfoType)
string	getFieldType (string className, string fieldName)
const char **	getFinfoTypes ()
	finalize() More...
PyObject *	getLookupField (ObjId oid, char *fieldName, PyObject *key)
PyObject *	getObjIdAttr (_ObjId *oid, string attribute)
Id	getShell (int argc, char **argv)
	setup_runtime_env() More...
PyMODINIT_FUNC	init_moose ()
char	innerType (char)
template<class KeyType >
PyObject *	lookup_value (const ObjId &oid, string fname, char value_type_code, char key_type_code, PyObject *key)
PyObject *	moose_connect (PyObject *dummy, PyObject *args)
PyObject *	moose_copy (PyObject *dummy, PyObject *args, PyObject *kwargs)
PyObject *	moose_delete (PyObject *dummy, PyObject *args)
PyObject *	moose_element (PyObject *dummy, PyObject *args)
PyObject *	moose_ElementField_getattro (_Field *self, PyObject *attr)
PyObject *	moose_ElementField_getDataId (_Field *self, void *closure)
PyObject *	moose_ElementField_getId (_Field *self, void *closure)
PyObject *	moose_ElementField_getItem (_Field *self, Py_ssize_t index)
Py_ssize_t	moose_ElementField_getLen (_Field *self, void *closure)
PyObject *	moose_ElementField_getName (_Field *self, void *closure)
PyObject *	moose_ElementField_getNum (_Field *self, void *closure)
PyObject *	moose_ElementField_getOwner (_Field *self, void *closure)
PyObject *	moose_ElementField_getPath (_Field *self, void *closure)
PyObject *	moose_ElementField_getSlice (_Field *self, Py_ssize_t start, Py_ssize_t end)
int	moose_ElementField_init (_Field *self, PyObject *args, PyObject *kwargs)
int	moose_ElementField_setattro (_Field *self, PyObject *attr, PyObject *value)
int	moose_ElementField_setNum (_Field *self, PyObject *num, void *closure)
PyObject *	moose_exists (PyObject *dummy, PyObject *args)
void	moose_Field_dealloc (_Field *self)
long	moose_Field_hash (_Field *self)
	Return the hash of the string {objectpath}.{fieldName} More...
int	moose_Field_init (_Field *self, PyObject *args, PyObject *kwds)
PyObject *	moose_Field_repr (_Field *self)
	String representation of fields is {objectpath}.{fieldName} More...
PyObject *	moose_getCwe (PyObject *dummy, PyObject *args)
PyObject *	moose_getField (PyObject *dummy, PyObject *args)
PyObject *	moose_getFieldDict (PyObject *dummy, PyObject *args)
int	moose_Id_contains (_Id *self, PyObject *args)
PyObject *	moose_Id_delete (_Id *self)
PyObject *	moose_Id_getattro (_Id *self, PyObject *attr)
PyObject *	moose_Id_getItem (_Id *self, Py_ssize_t index)
Py_ssize_t	moose_Id_getLength (_Id *self)
PyObject *	moose_Id_getPath (_Id *self)
PyObject *	moose_Id_getShape (_Id *self)
PyObject *	moose_Id_getSlice (_Id *self, Py_ssize_t start, Py_ssize_t end)
PyObject *	moose_Id_getValue (_Id *self)
long	moose_Id_hash (_Id *self)
int	moose_Id_init (_Id *self, PyObject *args, PyObject *kwargs)
PyObject *	moose_Id_repr (_Id *self)
PyObject *	moose_Id_richCompare (_Id *self, PyObject *args, int op)
int	moose_Id_setattro (_Id *self, PyObject *attr, PyObject *value)
PyObject *	moose_Id_setField (_Id *self, PyObject *args)
PyObject *	moose_Id_str (_Id *self)
PyObject *	moose_Id_subscript (_Id *self, PyObject *op)
PyObject *	moose_isRunning (PyObject *dummy, PyObject *args)
PyObject *	moose_loadModel (PyObject *dummy, PyObject *args)
PyObject *	moose_LookupField_getItem (_Field *self, PyObject *key)
int	moose_LookupField_setItem (_Field *self, PyObject *key, PyObject *value)
PyObject *	moose_move (PyObject *dummy, PyObject *args)
PyObject *	moose_ObjId_connect (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_get_destField_attr (PyObject *self, void *closure)
PyObject *	moose_ObjId_get_elementField_attr (PyObject *self, void *closure)
PyObject *	moose_ObjId_get_lookupField_attr (PyObject *self, void *closure)
PyObject *	moose_ObjId_getattro (_ObjId *self, PyObject *attr)
PyObject *	moose_ObjId_getDataIndex (_ObjId *self)
PyObject *	moose_ObjId_getField (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_getFieldIndex (_ObjId *self)
PyObject *	moose_ObjId_getFieldNames (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_getFieldType (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_getId (_ObjId *self)
PyObject *	moose_ObjId_getItem (_ObjId *self, Py_ssize_t index)
Py_ssize_t	moose_ObjId_getLength (_ObjId *self)
PyObject *	moose_ObjId_getLookupField (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_getNeighbors (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_getSlice (_ObjId *self, Py_ssize_t start, Py_ssize_t end)
long	moose_ObjId_hash (_ObjId *self)
int	moose_ObjId_init (_ObjId *self, PyObject *args, PyObject *kwargs)
PyObject *	moose_ObjId_repr (_ObjId *self)
PyObject *	moose_ObjId_richcompare (_ObjId *self, PyObject *args, int op)
int	moose_ObjId_setattro (_ObjId *self, PyObject *attr, PyObject *value)
PyObject *	moose_ObjId_setDestField (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_setField (_ObjId *self, PyObject *args)
PyObject *	moose_ObjId_setLookupField (_ObjId *self, PyObject *args)
PyObject *	moose_quit (PyObject *dummy)
PyObject *	moose_reinit (PyObject *dummy, PyObject *args)
PyObject *	moose_seed (PyObject *dummy, PyObject *args)
PyObject *	moose_setClock (PyObject *dummy, PyObject *args)
PyObject *	moose_setCwe (PyObject *dummy, PyObject *args)
PyObject *	moose_start (PyObject *dummy, PyObject *args)
PyObject *	moose_stop (PyObject *dummy, PyObject *args)
PyObject *	moose_syncDataHandler (PyObject *dummy, PyObject *target)
PyObject *	moose_useClock (PyObject *dummy, PyObject *args)
PyObject *	moose_wildcardFind (PyObject *dummy, PyObject *args)
PyObject *	oid_to_element (ObjId oid)
int	parseFinfoType (string className, string finfoType, string fieldName, vector< string > &typeVec)
vector< int >	pysequence_to_dimvec (PyObject *dims)
template<typename T >
vector< T > *	PySequenceToVector (PyObject *seq, char typecode)
template<typename T >
vector< vector< T > > *	PySequenceToVectorOfVectors (PyObject *seq, char typecode)
template<class KeyType >
int	set_lookup_value (const ObjId &oid, string fname, char value_type_code, char key_type_code, PyObject *key, PyObject *value_obj)
PyObject *	setDestFinfo (ObjId obj, string fieldName, PyObject *arg, string argType)
template<class A >
PyObject *	setDestFinfo1 (ObjId obj, string fieldName, PyObject *arg1, char type1, A arg2)
PyObject *	setDestFinfo2 (ObjId obj, string fieldName, PyObject *arg1, char type1, PyObject *arg2, char type2)
int	setLookupField (ObjId oid, char *fieldName, PyObject *key, PyObject *value)
char	shortType (string)
void *	to_cpp (PyObject *object, char typecode)
PyObject *	to_py (void *obj, char typecode)
PyObject *	to_pytuple (void *obj, char typecode)

Variables
static struct module_state	_state
union {
unsigned char   bytes [4]
uint32_t   value
}	o32_host_order = { { 0, 1, 2, 3 } }

Macro Definition Documentation

#define ElementField_Check

(

v

)

(Py_TYPE(v) == &moose_ElementField)

Definition at line 100 of file moosemodule.h.

#define ElementField_SubtypeCheck

(

v

)

(PyType_IsSubtype(Py_TYPE(v), &moose_ElementField))

Definition at line 101 of file moosemodule.h.

Referenced by moose_element().

#define GETSTATE

(

m

)

(&_state)

Definition at line 67 of file moosemodule.h.

Referenced by MODINIT().

#define Id_Check

(

v

)

(Py_TYPE(v) == &IdType)

Definition at line 95 of file moosemodule.h.

Referenced by moose_ObjId_init_from_id().

#define Id_SubtypeCheck

(

v

)

(PyType_IsSubtype(Py_TYPE(v),&IdType))

Definition at line 96 of file moosemodule.h.

Referenced by moose_connect(), and moose_Id_init().

#define LookupField_Check

(

v

)

(Py_TYPE(v) == &moose_LookupField)

Definition at line 99 of file moosemodule.h.

#define maxArgs   10

Definition at line 88 of file moosemodule.h.

Referenced by moose_ObjId_setDestField(), and parseFinfoType().

#define minArgs   1

Definition at line 84 of file moosemodule.h.

Referenced by moose_ObjId_setDestField().

#define O32_HOST_ORDER   (o32_host_order.value)

Definition at line 45 of file moosemodule.h.

#define ObjId_Check

(

v

)

(Py_TYPE(v) == &ObjIdType)

Definition at line 97 of file moosemodule.h.

#define ObjId_SubtypeCheck

(

v

)

(PyType_IsSubtype(Py_TYPE(v), &ObjIdType))

Definition at line 98 of file moosemodule.h.

Referenced by moose_connect(), moose_Id_contains(), and moose_Id_init().

#define RAISE_INVALID_ID	(		ret,
			msg
	)

Value:

{                            \
        PyErr_SetString(PyExc_ValueError, msg": invalid Id");   \
        return ret;                                             \
    }

Definition at line 71 of file moosemodule.h.

Referenced by moose_connect(), moose_copy(), moose_delete(), moose_ElementField_getattro(), moose_ElementField_getDataId(), moose_ElementField_getId(), moose_ElementField_getItem(), moose_ElementField_getLen(), moose_ElementField_getNum(), moose_ElementField_getPath(), moose_ElementField_getSlice(), moose_ElementField_setattro(), moose_ElementField_setNum(), moose_Field_hash(), moose_Field_init(), moose_Field_repr(), moose_getField(), moose_Id_delete(), moose_Id_getattro(), moose_Id_getItem(), moose_Id_getLength(), moose_Id_getPath(), moose_Id_getShape(), moose_Id_getSlice(), moose_Id_repr(), moose_Id_setattro(), moose_Id_setField(), moose_Id_str(), moose_move(), moose_ObjId_connect(), moose_ObjId_get_destField_attr(), moose_ObjId_get_elementField_attr(), moose_ObjId_get_lookupField_attr(), moose_ObjId_getattro(), moose_ObjId_getDataIndex(), moose_ObjId_getField(), moose_ObjId_getFieldIndex(), moose_ObjId_getFieldNames(), moose_ObjId_getFieldType(), moose_ObjId_getId(), moose_ObjId_getLookupField(), moose_ObjId_getNeighbors(), moose_ObjId_hash(), moose_ObjId_init_from_id(), moose_ObjId_repr(), moose_ObjId_richcompare(), moose_ObjId_setattro(), moose_ObjId_setDestField(), moose_ObjId_str(), and moose_setCwe().

#define RAISE_TYPE_ERROR	(		ret,
			type
	)

Value:

{                           \
        PyErr_SetString(PyExc_TypeError, "require " #type);     \
        return ret;                                             \
    }

Definition at line 76 of file moosemodule.h.

#define SET_LOOKUP_VALUE

(

TYPE

)

Value:

{                                                                   \
        TYPE * value = (TYPE*)to_cpp(value_obj, value_type_code);       \
        if (value){                                                     \
            success = LookupField < KeyType, TYPE > ::set(oid, fname, *cpp_key, *value); \
            delete value;                                               \
            delete cpp_key;                                             \
        }                                                               \
        break;                                                          \
    }

Referenced by set_lookup_value().

#define SHELLPTR   (reinterpret_cast<Shell*>(getShell(0, NULL).eref().data()))

Definition at line 105 of file moosemodule.h.

Referenced by create_Id_from_path(), deleteObjId(), finalize(), MODINIT(), moose_connect(), moose_copy(), moose_getCwe(), moose_isRunning(), moose_loadModel(), moose_move(), moose_ObjId_connect(), moose_reinit(), moose_setClock(), moose_setCwe(), moose_start(), moose_stop(), and moose_useClock().

Enumeration Type Documentation

anonymous enum

Enumerator
O32_LITTLE_ENDIAN
O32_BIG_ENDIAN
O32_PDP_ENDIAN

Definition at line 32 of file moosemodule.h.

{
    O32_LITTLE_ENDIAN = 0x03020100ul,
    O32_BIG_ENDIAN = 0x00010203ul,
    O32_PDP_ENDIAN = 0x01000302ul
};

Function Documentation

template<class A >

PyObject* _set_vector_destFinfo	(	ObjId	obj,
		string	fieldName,
		PyObject *	value,
		char	vtypecode
	)

Definition at line 578 of file moosemodule.h.

References moose::error, and to_cpp().

{
    ostringstream error;
    if (!PySequence_Check(value))
    {
        PyErr_SetString(PyExc_TypeError, "For setting vector field, specified value must be a sequence." );
        return NULL;
    }
    vector<A> * _value = (vector < A > *)to_cpp(value, vtypecode);
    if (_value == NULL)
    {
        return NULL;
    }
    bool ret = SetGet1< vector < A > >::set(obj, fieldName, *_value);
    delete _value;
    if (ret)
    {
        Py_RETURN_TRUE;
    }
    else
    {
        Py_RETURN_FALSE;
    }
}

Here is the call graph for this function:

PyObject* convert_and_set_tuple_entry	(	PyObject *	tuple,
		unsigned int	index,
		void *	vptr,
		char	typecode
	)

Inner function to convert C++ object at vptr and set tuple entry ii to the created PyObject. typecode is passed to to_cpp for conversion. If error occurs while setting tuple antry, it decrements the refcount of the tuple and returns NULL. Returns the tuple on success.

Definition at line 491 of file moosemodule.cpp.

References to_py(), and verbosity.

Referenced by to_pytuple().

{
    PyObject * item = to_py(vptr, typecode);
    if (item == NULL)
    {
        return NULL; // the error message would have been populated by to_cpp
    }
    if (PyTuple_SetItem(tuple, (Py_ssize_t)index, item) != 0)
    {
        PyErr_SetString(PyExc_RuntimeError, "convert_and_set_tuple_entry: could not set tuple entry.");
        return NULL;
    }
#ifndef NDEBUG
    if (verbosity > 2)
    {
        cout << "Set tuple " << tuple << " entry " << index << " with " << item << endl;
    }
#endif
    return tuple;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Id create_Id_from_path	(	string	path,
		unsigned int	numData,
		unsigned int	isGlobal,
		string	type
	)

Referenced by moose_ObjId_init_from_path().

Here is the caller graph for this function:

int defineAllClasses

(

PyObject *

module_dict

)

Go through all elements under /classes and ask for defining a Python class for it.

Definition at line 2461 of file moosemodule.cpp.

References defineClass(), Cinfo::find(), and verbosity.

Referenced by MODINIT().

{
    static vector <Id> classes(Field< vector<Id> >::get(ObjId("/classes"),
                               "children"));
    for (unsigned ii = 0; ii < classes.size(); ++ii)
    {
        const string& className = classes[ii].element()->getName();
        if (verbosity > 0)
        {
            cout << "\nCreating " << className << endl;
        }
        const Cinfo * cinfo = Cinfo::find(className);
        if (!cinfo)
        {
            cerr << "Error: no cinfo found with name " << className << endl;
            return 0;
        }
        if (!defineClass(module_dict, cinfo))
        {
            return 0;
        }
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int defineClass	(	PyObject *	module_dict,
		const Cinfo *	cinfo
	)

Definition at line 2540 of file moosemodule.cpp.

References Cinfo::baseCinfo(), defineClass(), defineDestFinfos(), defineElementFinfos(), defineLookupFinfos(), get_getsetdefs(), get_moose_classes(), Cinfo::getBaseClass(), Cinfo::name(), ObjIdType, and verbosity.

Referenced by defineAllClasses(), and defineClass().

{
    const string& className = cinfo->name();
    map <string, PyTypeObject * >::iterator existing =
        get_moose_classes().find(className);
    if (existing != get_moose_classes().end())
    {
        return 1;
    }
    const Cinfo* base = cinfo->baseCinfo();
#ifndef NDEBUG
    if (verbosity > 1)
    {
        cout << "Defining class " << className << endl; //" with base=" << base->name() << endl;
    }
#endif
    if (base && !defineClass(module_dict, base))
    {
        return 0;
    }

    string str = "moose." + className;

    PyTypeObject * new_class =
        (PyTypeObject*)PyType_Type.tp_alloc(&PyType_Type, 0);
// Python3 does not like it without heaptype: aborts on import
// Fatal Python error:
// type_traverse() called for non-heap type 'moose.Neutral'
#ifdef PY3K
    new_class->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
    PyHeapTypeObject* et = (PyHeapTypeObject*)new_class;
    et->ht_name = PyUnicode_FromString(className.c_str());
#if PY_MINOR_VERSION >= 3
    et->ht_qualname = PyUnicode_FromString(str.c_str());
#endif
#else
    new_class->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
#endif
    /*
      Thu Jul 9 09:58:09 IST 2015 - commenting out
      Py_TPFLAGS_HEAPTYPE because it causes segfault on accessing
      __class__ attribute of instances. Bug # 168. Another
      possible solution would be to catch __class__ request in
      tp_getattro and INCREF the class object when returning the
      same.

      ------
    should we avoid Py_TPFLAGS_HEAPTYPE as it imposes certain
    limitations:
    http://mail.python.org/pipermail/python-dev/2009-July/090921.html
    But otherwise somehow GC tries tp_traverse on these classes
    (even when I unset Py_TPFLAGS_HAVE_GC) and fails the
    assertion in debug build of Python:

    python: Objects/typeobject.c:2683: type_traverse: Assertion `type->tp_flags & Py_TPFLAGS_HEAPTYPE' failed.

    In released versions of Python there is a crash at
    Py_Finalize().

    Also if HEAPTYPE is true, then help(classname) causes a
    segmentation fault as it tries to convert the class object
    to a heaptype object (resulting in an invalid pointer). If
    heaptype is not set it uses tp_name to print the help.
    Py_SIZE(new_class) = sizeof(_ObjId);
    */
    new_class->tp_name = strdup(str.c_str());
    new_class->tp_doc = moose_Class_documentation;

    //strncpy(new_class->tp_doc, moose_Class_documentation, strlen(moose_Class_documentation));
    map<string, PyTypeObject *>::iterator base_iter =
        get_moose_classes().find(cinfo->getBaseClass());
    if (base_iter == get_moose_classes().end())
    {
        new_class->tp_base = &ObjIdType;
    }
    else
    {
        new_class->tp_base = base_iter->second;
    }
    Py_INCREF(new_class->tp_base);
    // Define all the lookupFields
    if (!defineLookupFinfos(cinfo))
    {
        return 0;
    }
    // Define the destFields
    if (!defineDestFinfos(cinfo))
    {
        return 0;
    }

    // Define the element fields
    if (!defineElementFinfos(cinfo))
    {
        return 0;
    }
    // #ifndef NDEBUG
    //         cout << "Get set defs:" << className << endl;
    //         for (unsigned int ii = 0; ii < get_getsetdefs()[className].size(); ++ii){
    //             cout << ii;
    //             if (get_getsetdefs()[className][ii].name != NULL){
    //                 cout << ": " << get_getsetdefs()[className][ii].name;
    //             } else {
    //                 cout << "Empty";
    //             }
    //             cout << endl;
    //         }
    //         cout << "End getsetdefs: " << className << endl;
    // #endif
    // The getsetdef array must be terminated with empty objects.
    PyGetSetDef empty;
    empty.name = NULL;
    get_getsetdefs()[className].push_back(empty);
    get_getsetdefs()[className].back().name = NULL;
    new_class->tp_getset = &(get_getsetdefs()[className][0]);
    /*
      Cannot do this for HEAPTYPE ?? but pygobject.c does this in
      pygobject_register_class
    */
    if (PyType_Ready(new_class) < 0)
    {
        cerr << "Fatal error: Could not initialize class '" << className
             << "'" << endl;
        return 0;
    }
    get_moose_classes().insert(pair<string, PyTypeObject*> (className, new_class));
    Py_INCREF(new_class);

#ifdef PY3K
    PyDict_SetItemString(new_class->tp_dict, "__module__", PyUnicode_InternFromString("moose"));
#endif
    // string doc = const_cast<Cinfo*>(cinfo)->getDocs();
    // PyDict_SetItemString(new_class->tp_dict, "__doc__", PyString_FromString(" \0"));
    // PyDict_SetItemString(module_dict, className.c_str(), (PyObject *)new_class);
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int defineDestFinfos

(

const Cinfo *

cinfo

)

Definition at line 2714 of file moosemodule.cpp.

References get_getsetdefs(), Cinfo::getNumDestFinfo(), moose_ObjId_get_destField_attr(), Finfo::name(), Cinfo::name(), name, and verbosity.

Referenced by defineClass().

{
    const string& className = cinfo->name();
#ifndef NDEBUG
    if (verbosity > 1)
    {
        cout << "\tCreating destField attributes for " << className << endl;
    }
#endif
    vector <PyGetSetDef>& vec = get_getsetdefs()[className];
    /*
      We do not know the final number of user-accessible
      destFinfos as we have to ignore the destFinfos starting
      with get/set. So use a vector instead of C array.
    */
    size_t currIndex = vec.size();
    for (unsigned int ii = 0; ii < cinfo->getNumDestFinfo(); ++ii)
    {
        Finfo * destFinfo = const_cast<Cinfo*>(cinfo)->getDestFinfo(ii);
        const string& name = destFinfo->name();
        /*
          get_{xyz} and set_{xyz} are internal destFinfos for
          accessing valueFinfos. Ignore them.

          With the '_' removed from internal get/set for value
          fields, we cannot separate them out. - Subha Fri Jan 31
          16:43:51 IST 2014

          The policy changed in the past and hence the following were commented out.
          - Subha Tue May 26 00:25:28 EDT 2015
         */
        // if (name.find("get") == 0 || name.find("set") == 0){
        //     continue;
        // }
        PyGetSetDef destFieldGetSet;
        vec.push_back(destFieldGetSet);

        vec[currIndex].name = strdup(name.c_str());
        vec[currIndex].doc = (char*) "Destination field";
        vec[currIndex].get = (getter)moose_ObjId_get_destField_attr;
        PyObject *args = PyTuple_New(1);
        if (!args || !vec[currIndex].name) {
            cerr << "moosemodule.cpp: defineDestFinfos: allocation failed\n";
            return 0;
        }
        PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
        vec[currIndex].closure = (void*)args;

        //LOG( debug, "\tCreated destField " << vec[currIndex].name );

        ++currIndex;
    } // ! for

    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int defineElementFinfos

(

const Cinfo *

cinfo

)

Definition at line 2863 of file moosemodule.cpp.

References get_getsetdefs(), Cinfo::getNumFieldElementFinfo(), moose_ObjId_get_elementField_attr(), Cinfo::name(), name, and verbosity.

Referenced by defineClass().

{
    const string & className = cinfo->name();
#ifndef NDEBUG
    if (verbosity > 1)
    {
        cout << "\tDefining elementFields for " << className << endl;
    }
#endif
    unsigned int num = cinfo->getNumFieldElementFinfo();
    unsigned int currIndex = get_getsetdefs()[className].size();
    for (unsigned int ii = 0; ii < num; ++ii)
    {
        const string& name = const_cast<Cinfo*>(cinfo)->getFieldElementFinfo(ii)->name();
        PyGetSetDef getset;
        get_getsetdefs()[className].push_back(getset);
        get_getsetdefs()[className][currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
        strncpy(const_cast<char*>(get_getsetdefs()[className][currIndex].name)
                , const_cast<char*>(name.c_str()), name.size());
        get_getsetdefs()[className][currIndex].doc = (char*) "Element field";
        get_getsetdefs()[className][currIndex].get = (getter)moose_ObjId_get_elementField_attr;
        PyObject * args = PyTuple_New(1);
        PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
        get_getsetdefs()[className][currIndex].closure = (void*)args;
#ifndef NDEBUG
        if (verbosity > 1)
        {
            cout << "\tDefined elementField " << get_getsetdefs()[className][currIndex].name << endl;
        }
#endif

        ++currIndex;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int defineLookupFinfos

(

const Cinfo *

cinfo

)

Definition at line 2503 of file moosemodule.cpp.

References get_getsetdefs(), Cinfo::getNumLookupFinfo(), moose_ObjId_get_lookupField_attr(), Cinfo::name(), name, and verbosity.

Referenced by defineClass().

{
    const string & className = cinfo->name();
#ifndef NDEBUG
    if (verbosity > 1)
    {
        cout << "\tDefining lookupFields for " << className << endl;
    }
#endif
    unsigned int num = cinfo->getNumLookupFinfo();
    unsigned int currIndex = get_getsetdefs()[className].size();
    for (unsigned int ii = 0; ii < num; ++ii)
    {
        const string& name = const_cast<Cinfo*>(cinfo)->getLookupFinfo(ii)->name();
        PyGetSetDef getset;
        get_getsetdefs()[className].push_back(getset);
        get_getsetdefs()[className][currIndex].name = (char*)calloc(name.size() + 1, sizeof(char));
        strncpy(const_cast<char*>(get_getsetdefs()[className][currIndex].name)
                , const_cast<char*>(name.c_str()), name.size());
        get_getsetdefs()[className][currIndex].doc = (char*) "Lookup field";
        get_getsetdefs()[className][currIndex].get = (getter)moose_ObjId_get_lookupField_attr;
        PyObject * args = PyTuple_New(1);
        PyTuple_SetItem(args, 0, PyString_FromString(name.c_str()));
        get_getsetdefs()[className][currIndex].closure = (void*)args;
#ifndef NDEBUG
        if (verbosity > 1)
        {
            cout << "\tDefined lookupField " << get_getsetdefs()[className][currIndex].name << endl;
        }
#endif

        ++currIndex;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* deleteObjId

(

ObjId

obj

)

Definition at line 522 of file vec.cpp.

References SHELLPTR, and verbosity.

Referenced by moose_delete(), and moose_Id_delete().

{
#ifndef NDEBUG
    if (verbosity > 1)
    {
        cout << "Deleting ObjId " << oid << endl;
    }
#endif
    SHELLPTR->doDelete(oid);
    Py_RETURN_NONE;
}

Here is the caller graph for this function:

const map<string, string>& get_field_alias

(

)

map of fields which are aliased in Python to avoid collision with Python keywords.

Definition at line 850 of file moosemodule.cpp.

Referenced by moose_ElementField_getattro(), moose_Id_getattro(), and moose_ObjId_getattro().

{
    static map<string, string> alias;
    if (alias.empty())
    {
        // alias["class_"] = "class";
        alias["lambda_"] = "lambda";
    }
    return alias;
}

Here is the caller graph for this function:

map<string, vector <PyGetSetDef> >& get_getsetdefs

(

)

Definition at line 840 of file moosemodule.cpp.

Referenced by defineClass(), defineDestFinfos(), defineElementFinfos(), defineLookupFinfos(), and finalize().

{
    static map<string, vector <PyGetSetDef>  > getset_defs;
    return getset_defs;
}

Here is the caller graph for this function:

map<string, PyTypeObject *>& get_moose_classes

(

)

Definition at line 833 of file moosemodule.cpp.

Referenced by defineClass(), getBaseClass(), MODINIT(), moose_ObjId_init_from_path(), moose_ObjId_setattro(), and oid_to_element().

{
    static map<string, PyTypeObject *> defined_classes;
    return defined_classes;
}

Here is the caller graph for this function:

int get_npy_typenum

(

const type_info &

ctype

)

template<typename KeyType , typename ValueType >

PyObject* get_simple_lookupfield	(	ObjId	oid,
		string	fieldname,
		KeyType	key,
		char	vtypecode
	)

Definition at line 378 of file moosemodule.h.

References LookupField< L, A >::get(), to_py(), and value.

{
    ValueType value = LookupField<KeyType, ValueType>::get(oid, fieldname, key);
    PyObject * v = to_py(&value, vtypecode);
    return v;
}

Here is the call graph for this function:

template<typename KeyType , typename ValueType >

PyObject* get_vec_lookupfield	(	ObjId	oid,
		string	fieldname,
		KeyType	key,
		char	vtypecode
	)

Definition at line 371 of file moosemodule.h.

References innerType(), to_pytuple(), and value.

{
    vector<ValueType> value = LookupField<KeyType, vector<ValueType> >::get(oid, fieldname, key);
    return to_pytuple((void*)&value, innerType(vtypecode));
}

Here is the call graph for this function:

PyTypeObject* getBaseClass

(

PyObject *

self

)

Utility function to traverse python class hierarchy to reach closest base class. Ideally we should go via mro

Definition at line 1294 of file moosemodule.cpp.

References get_moose_classes(), and ObjIdType.

Referenced by moose_ObjId_init_from_path(), and testCinfoFields().

{
    extern PyTypeObject ObjIdType;
    string basetype_str = "";
    PyTypeObject * base = NULL;
    for (base = Py_TYPE(self);
            base != &ObjIdType; base = base->tp_base)
    {
        basetype_str = base->tp_name;
        size_t dot = basetype_str.find('.');
        basetype_str = basetype_str.substr(dot+1);
        if (get_moose_classes().find(basetype_str) !=
                get_moose_classes().end())
        {
            return base;
        }
    }
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vector<string> getFieldNames	(	string	className,
		string	finfoType
	)

string getFieldType	(	string	className,
		string	fieldName
	)

const char** getFinfoTypes

(

)

finalize()

Return list of available Finfo types. Place holder for static const to avoid static initialization issues.

Definition at line 1064 of file moosemodule.cpp.

Referenced by moose_ObjId_getFieldNames().

{
    static const char * finfoTypes[] = {"valueFinfo",
                                        "srcFinfo",
                                        "destFinfo",
                                        "lookupFinfo",
                                        "sharedFinfo",
                                        "fieldElementFinfo",
                                        0
                                       };
    return finfoTypes;
}

Here is the caller graph for this function:

PyObject* getLookupField	(	ObjId	target,
		char *	fieldName,
		PyObject *	key
	)

Inner function for looking up value from LookupField on object with ObjId target.

args should be a tuple (lookupFieldName, key)

Definition at line 1295 of file melement.cpp.

References moose::error, Field< A >::get(), parseFinfoType(), and shortType().

Referenced by moose_LookupField_getItem(), and moose_ObjId_getLookupField().

{
    vector<string> type_vec;
    if (parseFinfoType(Field<string>::get(target, "className"), "lookupFinfo", string(fieldName), type_vec) < 0)
    {
        ostringstream error;
        error << "Cannot handle key type for LookupField `" << Field<string>::get(target, "className") << "." << fieldName << "`.";
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return NULL;
    }
    if (type_vec.size() != 2)
    {
        ostringstream error;
        error << "LookupField type signature should be <keytype>, <valuetype>. But for `"
              << Field<string>::get(target, "className") << "." << fieldName << "` got " << type_vec.size() << " components." ;
        PyErr_SetString(PyExc_AssertionError, error.str().c_str());
        return NULL;
    }
    PyObject * ret = NULL;
    char key_type_code = shortType(type_vec[0]);
    char value_type_code = shortType(type_vec[1]);
    switch(key_type_code)
    {
    case 'b':
    {
        ret = lookup_value <bool> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'c':
    {
        ret = lookup_value <char> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'h':
    {
        ret = lookup_value <short> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'H':
    {
        ret = lookup_value <unsigned short> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'i':
    {
        ret = lookup_value <int> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'I':
    {
        ret = lookup_value <unsigned int> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'l':
    {
        ret = lookup_value <long> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'k':
    {
        ret = lookup_value <unsigned long> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'L':
    {
        ret = lookup_value <long long> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'K':
    {
        ret = lookup_value <unsigned long long> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'd':
    {
        ret = lookup_value <double> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'f':
    {
        ret = lookup_value <float> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 's':
    {
        ret = lookup_value <string> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'x':
    {
        ret = lookup_value <Id> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'y':
    {
        ret = lookup_value <ObjId> (target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'D':
    {
        ret = lookup_value < vector <double> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'S':
    {
        ret = lookup_value < vector <string> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'X':
    {
        ret = lookup_value < vector <Id> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'Y':
    {
        ret = lookup_value < vector <ObjId> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'v':
    {
        ret = lookup_value < vector <int> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'N':
    {
        ret = lookup_value < vector <unsigned int> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'P':
    {
        ret = lookup_value < vector <unsigned long> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'F':
    {
        ret = lookup_value < vector <float> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'w':
    {
        ret = lookup_value < vector <short> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    case 'C':
    {
        ret = lookup_value < vector <char> >(target, string(fieldName), value_type_code, key_type_code, key);
        break;
    }
    default:
        ostringstream error;
        error << "Unhandled key type `" << type_vec[0] << "` for " << Field<string>::get(target, "className") << "." << fieldName;
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* getObjIdAttr	(	_ObjId *	oid,
		string	attribute
	)

Id getShell	(	int	argc,
		char **	argv
	)

setup_runtime_env()

Create the shell instance unless already created. This calls basecode/main.cpp:init(argc, argv) to do the initialization.

Return the Id of the Shell object.

Definition at line 967 of file moosemodule.cpp.

References Eref::data(), doRegressionTests, Shell::doSetClock(), doUnitTests, Shell::doUseClock(), Id::eref(), init(), mooseBenchmarks(), mpiTests(), Shell::myNode(), nonMpiTests(), Shell::numNodes(), and processTests().

Referenced by finalize(), handle_keyboard_interrupts(), and MODINIT().

{
    static int inited = 0;
    if (inited)
    {
        return Id(0);
    }
    bool dounit = doUnitTests != 0;
    bool doregress = doRegressionTests != 0;
    unsigned int doBenchmark = 0;
    // Utilize the main::init function which has friend access to Id
    Id shellId = init(argc, argv, dounit, doregress, doBenchmark );
    inited = 1;
    Shell * shellPtr = reinterpret_cast<Shell*>(shellId.eref().data());
    if (dounit)
    {
        nonMpiTests( shellPtr ); // These tests do not need the process loop.
    }
    if ( shellPtr->myNode() == 0 )
    {
        if ( Shell::numNodes() > 1 )
        {
            // Use the last clock for the postmaster, so that it is called
            // after everything else has been processed and all messages
            // are ready to send out.
            shellPtr->doUseClock( "/postmaster", "process", 9 );
            shellPtr->doSetClock( 9, 1.0 ); // Use a sensible default.
        }
#ifdef DO_UNIT_TESTS
        if ( dounit )
        {
            mpiTests();
            processTests( shellPtr );
        }
        // if ( doRegressionTests ) regressionTests();
#endif
        // These are outside unit tests because they happen in optimized
        // mode, using a command-line argument. As soon as they are done
        // the system quits, in order to estimate timing.
        if ( doBenchmark != 0 )
        {
            mooseBenchmarks( doBenchmark );
        }
    }
    return shellId;
} 

Here is the call graph for this function:

Here is the caller graph for this function:

PyMODINIT_FUNC init_moose

(

)

char innerType

(

char

)

Definition at line 104 of file types.cpp.

Referenced by get_vec_lookupfield(), and to_py().

                             {
    static map<char, char> innerTypeMap;
    if (innerTypeMap.empty()){
        innerTypeMap.insert(pair<char, char>('D', 'd')); // vector<double>
        innerTypeMap.insert(pair<char, char>('v', 'i')); // vector<int>
        innerTypeMap.insert(pair<char, char>('M', 'l')); // vector<long>
        innerTypeMap.insert(pair<char, char>('X', 'x')); // vector<Id>
        innerTypeMap.insert(pair<char, char>('Y', 'y')); // vector<ObjId>
        innerTypeMap.insert(pair<char, char>('C', 'c')); // vector<char>
        innerTypeMap.insert(pair<char, char>('w', 'h')); // vector<short>
        innerTypeMap.insert(pair<char, char>('N', 'I')); // vector<unsigned int>
        innerTypeMap.insert(pair<char, char>('P', 'k')); // vector<unsigned long>
        innerTypeMap.insert(pair<char, char>('A', 'L')); // vector<long long>
        innerTypeMap.insert(pair<char, char>('B', 'K')); // vector<unsigned long long>
        innerTypeMap.insert(pair<char, char>('F', 'f')); // vector<float>
        innerTypeMap.insert(pair<char, char>('S', 's')); // vector<string>
        innerTypeMap.insert(pair<char, char>('T', 'N')); // vector<vector<unsigned>>
        innerTypeMap.insert(pair<char, char>('Q', 'v')); // vector<vector<int>>
        innerTypeMap.insert(pair<char, char>('R', 'D')); // vector<vector<double>>
    }
    map<char, char>::iterator iter = innerTypeMap.find(typecode);
    if (iter == innerTypeMap.end()){
        return 0;
    }
    return iter->second;
}

Here is the caller graph for this function:

template<class KeyType >

PyObject* lookup_value	(	const ObjId &	oid,
		string	fname,
		char	value_type_code,
		char	key_type_code,
		PyObject *	key
	)

Definition at line 386 of file moosemodule.h.

References to_cpp().

{
    PyObject * ret = NULL;
    KeyType * cpp_key = (KeyType *)to_cpp(key, key_type_code);
    if (cpp_key == NULL)
    {
        return NULL;
    }
    // The case statements are arranged roughly in order of frequency
    // of that data type. This is an attempt to optimize. We cannot
    // use a map of function pointers because part of the template
    // will be unspecialized (or we need N^2 templated fn instances).
    switch (value_type_code)
    {
    case 'd':
        ret = get_simple_lookupfield< KeyType, double>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'D':
        ret = get_vec_lookupfield<KeyType, double>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'S':
        ret = get_vec_lookupfield<KeyType, string>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'i':
        ret = get_simple_lookupfield < KeyType, int >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'I':
        ret = get_simple_lookupfield < KeyType, unsigned int >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'y':
        ret = get_simple_lookupfield< KeyType, ObjId >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'x':
        ret = get_simple_lookupfield<KeyType, Id>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'l':
        ret = get_simple_lookupfield< KeyType, long >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'k':
        ret = get_simple_lookupfield< KeyType, unsigned long >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'f':
        ret = get_simple_lookupfield< KeyType, float >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'b': // boolean is a special case that PyBuildValue does not handle
        ret = get_simple_lookupfield < KeyType, bool >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'c':
        ret = get_simple_lookupfield < KeyType, char >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'h':
        ret = get_simple_lookupfield < KeyType, short >(oid, fname, *cpp_key, value_type_code);
        break;
    case 'H':
        ret = get_simple_lookupfield< KeyType, unsigned short >(oid, fname, *cpp_key, value_type_code);
        break;
#ifdef HAVE_LONG_LONG
    case 'L':
        ret = get_simple_lookupfield< KeyType, long long>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'K':
        ret = get_simple_lookupfield< KeyType, unsigned long long>(oid, fname, *cpp_key, value_type_code);
        break;
#endif
    case 'X':
        ret = get_vec_lookupfield<KeyType, Id>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'Y':
        ret = get_vec_lookupfield<KeyType, ObjId>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'v':
        ret = get_vec_lookupfield<KeyType, int>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'w':
        ret = get_vec_lookupfield<KeyType, short>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'M':
        ret = get_vec_lookupfield<KeyType, long>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'N':
        ret = get_vec_lookupfield<KeyType, unsigned int>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'P':
        ret = get_vec_lookupfield<KeyType, unsigned long>(oid, fname, *cpp_key, value_type_code);
        break;
    case 'F':
        ret = get_vec_lookupfield<KeyType, float>(oid, fname, *cpp_key, value_type_code);
        break;
    default:
        PyErr_SetString(PyExc_TypeError, "invalid value type");
    }
    delete cpp_key;
    return ret;
}

Here is the call graph for this function:

PyObject* moose_connect	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1982 of file moosemodule.cpp.

References ObjId::bad(), ObjId::id, _Id::id_, Id_SubtypeCheck, Id::isValid(), ObjId_SubtypeCheck, _ObjId::oid_, oid_to_element(), RAISE_INVALID_ID, and SHELLPTR.

{
    PyObject * srcPtr = NULL, * destPtr = NULL;
    char * srcField = NULL, * destField = NULL, * msgType = NULL;
    static char default_msg_type[] = "Single";
    if(!PyArg_ParseTuple(args, "OsOs|s:moose_connect", &srcPtr, &srcField, &destPtr, &destField, &msgType))
    {
        return NULL;
    }
    if (msgType == NULL)
    {
        msgType = default_msg_type;
    }
    ObjId dest, src;
    if (ObjId_SubtypeCheck(srcPtr))
    {
        _ObjId * _src = reinterpret_cast<_ObjId*>(srcPtr);
        src = _src->oid_;
    }
    else if (Id_SubtypeCheck(srcPtr))
    {
        _Id * _src = reinterpret_cast<_Id*>(srcPtr);
        src = ObjId(_src->id_);
    }
    else if (PyString_Check(srcPtr))
    {
        char * _src = PyString_AsString(srcPtr);
        src = ObjId(string(_src));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "source does not resolve to an element.");
        return NULL;
    }
    if (ObjId_SubtypeCheck(destPtr))
    {
        _ObjId * _dest = reinterpret_cast<_ObjId*>(destPtr);
        dest = _dest->oid_;
    }
    else if (Id_SubtypeCheck(destPtr))
    {
        _Id * _dest = reinterpret_cast<_Id*>(destPtr);
        dest = ObjId(_dest->id_);
    }
    else if (PyString_Check(destPtr))
    {
        char * _dest = PyString_AsString(destPtr);
        dest = ObjId(string(_dest));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "target does not resolve to an element.");
        return NULL;
    }
    if (!Id::isValid(dest.id) || !Id::isValid(src.id))
    {
        RAISE_INVALID_ID(NULL, "moose_connect");
    }
    ObjId mid = SHELLPTR->doAddMsg(msgType, src, string(srcField), dest, string(destField));
    if ( mid.bad() )
    {
        PyErr_SetString(PyExc_NameError, "check field names and type compatibility.");
        return NULL;
    }
    return oid_to_element(mid);
}

Here is the call graph for this function:

PyObject* moose_copy	(	PyObject *	dummy,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 1391 of file moosemodule.cpp.

References ObjId::bad(), Field< A >::get(), _Id::id_, Id::id_, IdType, Id::isValid(), name, ObjIdType, RAISE_INVALID_ID, and SHELLPTR.

{
    PyObject * src = NULL, * dest = NULL;
    char * newName = NULL;
    static const char * kwlist[] = {"src", "dest", "name", "n", "toGlobal", "copyExtMsg", NULL};
    unsigned int num=1, toGlobal=0, copyExtMsgs=0;
    if (!PyArg_ParseTupleAndKeywords(args, kwargs, "OO|sIII", const_cast<char**>(kwlist), &src, &dest, &newName, &num, &toGlobal, &copyExtMsgs))
    {
        return NULL;
    }
    Id _src;
    ObjId _dest;
    if (PyObject_IsInstance(src, (PyObject*)&IdType))
    {
        _src = ((_Id*)src)->id_;
    }
    else if (PyObject_IsInstance(src, (PyObject*)&ObjIdType))
    {
        _src = ((_ObjId*)src)->oid_.id;
    }
    else if (PyString_Check(src))
    {
        _src = Id(PyString_AsString(src));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Source must be instance of vec, element or string.");
        return NULL;
    }
    if (_src == Id())
    {
        PyErr_SetString(PyExc_ValueError, "Cannot make copy of moose shell.");
        return NULL;
    }
    if (PyObject_IsInstance(dest, (PyObject*)&IdType))
    {
        _dest = ObjId(((_Id*)dest)->id_);
    }
    else if (PyObject_IsInstance(dest, (PyObject*)&ObjIdType))
    {
        _dest = ((_ObjId*)dest)->oid_;
    }
    else if (PyString_Check(dest))
    {
        _dest = ObjId(PyString_AsString(dest));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "destination must be instance of vec, element or string.");
        return NULL;
    }
    if (!Id::isValid(_src))
    {
        RAISE_INVALID_ID(NULL, "moose_copy: invalid source Id.");
    }
    else if (_dest.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_copy: invalid destination.");
    }
    string name;
    if (newName == NULL)
    {
        // Use the original name if name is not specified.
        name = Field<string>::get(ObjId(_src, 0), "name");
    }
    else
    {
        name = string(newName);
    }
    _Id * tgt = PyObject_New(_Id, &IdType);
    tgt->id_ = SHELLPTR->doCopy(_src, _dest, name, num, toGlobal, copyExtMsgs);
    PyObject * ret = (PyObject*)tgt;
    return ret;
}

Here is the call graph for this function:

PyObject* moose_delete	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1544 of file moosemodule.cpp.

References ObjId::bad(), BADINDEX, deleteObjId(), IdType, ObjIdType, and RAISE_INVALID_ID.

{
    PyObject * obj;
    bool isId_ = false;
    bool isObjId_ = false;
    if (!PyArg_ParseTuple(args, "O:moose.delete", &obj))
    {
        return NULL;
    }
    // if (!PyObject_IsInstance(obj, (PyObject*)&IdType)){
    //     PyErr_SetString(PyExc_TypeError, "vec instance expected");
    //     return NULL;
    // }
    ObjId oid_;
    if (PyObject_IsInstance(obj, (PyObject*)&IdType))
    {
        oid_ = ((_Id*)obj)->id_;
        isId_ = true;
    }
    else if (PyObject_IsInstance(obj, (PyObject*)&ObjIdType))
    {
        oid_ = ((_ObjId*)obj)->oid_;
        isObjId_ = true;
    }
    else if (PyString_Check(obj))
    {
        oid_ = ObjId(PyString_AsString(obj));
    }
    else
    {
        PyErr_SetString(PyExc_ValueError, "cannot delete moose shell.");
        return NULL;
    }
    if (oid_ == ObjId())
    {
        PyErr_SetString(PyExc_ValueError, "cannot delete moose shell.");
        return NULL;
    }
    if ( oid_.bad() )
    {
        RAISE_INVALID_ID(NULL, "moose_delete");
    }
    deleteObjId(oid_);
    if (isId_)
    {
        ((_Id*)obj)->id_ = Id();
    }
    if (isObjId_)
    {
        ((_ObjId*)obj)->oid_ = ObjId(0, BADINDEX, BADINDEX);
    }
    // SHELLPTR->doDelete(((_Id*)obj)->id_);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_element	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 2931 of file moosemodule.cpp.

References ObjId::bad(), ElementField_SubtypeCheck, id, IdType, moose_ElementField_getId(), ObjIdType, oid_to_element(), and path.

{
    char * path = NULL;
    PyObject * obj = NULL;
    ObjId oid;
    unsigned nid = 0, did = 0, fidx = 0;
    Id id;
    unsigned int numData = 0;
    if (PyArg_ParseTuple(args, "s", &path))
    {
        oid = ObjId(path);
        //            cout << "Original Path " << path << ", Element Path: " << oid.path() << endl;
        if ( oid.bad() )
        {
            PyErr_SetString(PyExc_ValueError, ( std::string("moose_element: '")
                                                + std::string(path)
                                                + std::string("' does not exist!")
                                              ).c_str()
                           );
            return NULL;
        }
        PyObject * new_obj = oid_to_element(oid);
        if (new_obj)
        {
            return new_obj;
        }
        PyErr_SetString(PyExc_TypeError, "moose_element: unknown class");
        return NULL;
    }
    PyErr_Clear();
    if (PyArg_ParseTuple(args, "I|II", &nid, &did, &fidx))
    {
        oid = ObjId(id, did, fidx);
        // Todo: test for validity
        PyObject * new_obj = oid_to_element(oid);
        if (!new_obj)
        {
            PyErr_SetString(PyExc_RuntimeError, "moose_element: not a moose class.");
        }
        return new_obj;
    }
    PyErr_Clear();
    if (!PyArg_ParseTuple(args, "O|II", &obj, &did, &fidx))
    {
        PyErr_SetString(PyExc_TypeError, "moose_element: argument must be a path or an existing element or an vec");
        return NULL;
    }
    // PyErr_Clear();
    if (PyObject_IsInstance(obj, (PyObject*)&ObjIdType))
    {
        oid = ((_ObjId*)obj)->oid_;
    }
    else if (PyObject_IsInstance(obj, (PyObject*)&IdType))
    {
        oid = ObjId(((_Id*)obj)->id_, did, fidx); // TODO: check for validity
    }
    else if (ElementField_SubtypeCheck(obj))
    {
        oid = ObjId(((_Id*)moose_ElementField_getId((_Field*)obj, NULL))->id_);
    }
    if (oid.bad())
    {
        PyErr_SetString(PyExc_TypeError, "moose_element: cannot convert to moose element.");
        return NULL;
    }
    PyObject * new_obj = oid_to_element(oid);
    if (!new_obj)
    {
        PyErr_SetString(PyExc_RuntimeError, "moose_element: not a moose class.");
    }
    return new_obj;
}

Here is the call graph for this function:

PyObject* moose_ElementField_getattro	(	_Field *	self,
		PyObject *	attr
	)

Definition at line 685 of file mfield.cpp.

References Field< A >::get(), get_field_alias(), getFieldType(), Field< A >::getVec(), RAISE_INVALID_ID, shortType(), and to_pytuple().

{
    int new_attr = 0;
    PyObject * ret = NULL;
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getSlice");
    }
    char * field = PyString_AsString(attr);
    string className = Field<string>::get(self->myoid, "className");
    string type = getFieldType(className, field);
    if (type.empty())
    {
        // Check if this field name is aliased and update fieldname and type if so.
        map<string, string>::const_iterator it = get_field_alias().find(string(field));
        if (it != get_field_alias().end())
        {
            field = const_cast<char*>((it->second).c_str());
            type = getFieldType(Field<string>::get(self->myoid, "className"), it->second);
            // Update attr for next level (PyObject_GenericGetAttr) in case.
            new_attr = 1;
            attr = PyString_FromString(field);
        }
    }
    if (type.empty())
    {
        ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        if (new_attr)
        {
            Py_DECREF(attr);
            return ret;
        }
    }
    char ftype = shortType(type);
    switch (ftype)
    {
    case 'd':
    {
        vector < double > val;
        Field< double >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 's':
    {
        vector < string > val;
        Field< string >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'l':
    {
        vector < long > val;
        Field< long >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'x':
    {
        vector < Id > val;
        Field< Id >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'y':
    {
        vector < ObjId > val;
        Field< ObjId >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'i':
    {
        vector < int > val;
        Field< int >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'I':
    {
        vector < unsigned int > val;
        Field< unsigned int >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'k':
    {
        vector < unsigned long > val;
        Field< unsigned long >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'f':
    {
        vector < float > val;
        Field< float >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'b':
    {
        vector<bool> val;
        Field< bool >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'c':
    {
        vector < char > val;
        Field< char >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'h':
    {
        vector < short > val;
        Field< short >::getVec(self->myoid, string(field), val);
        ret = to_pytuple(&val, ftype);
        break;
    }
    case 'z':
    {
        PyErr_SetString(PyExc_NotImplementedError, "DataId handling not implemented yet.");
        break;
    }
    case 0:
    {
        ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        break;
    }
    default:
        PyErr_SetString(PyExc_ValueError, "unhandled field type.");
        break;
    }
    if (new_attr)
    {
        Py_DECREF(attr);
    }
    return ret;
}

Here is the call graph for this function:

PyObject* moose_ElementField_getDataId	(	_Field *	self,
		void *	closure
	)

Definition at line 602 of file mfield.cpp.

References RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getItem");
    }
    return Py_BuildValue("I", self->owner->oid_.dataIndex);
}

PyObject* moose_ElementField_getId	(	_Field *	self,
		void *	closure
	)

Definition at line 581 of file mfield.cpp.

References IdType, and RAISE_INVALID_ID.

Referenced by moose_element().

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_setNum");
    }
    Id myId(self->owner->oid_.path() + "/" + string(self->name));
    _Id * new_id = PyObject_New(_Id, &IdType);
    new_id->id_ = myId;
    return (PyObject*)new_id;
}

Here is the caller graph for this function:

PyObject* moose_ElementField_getItem	(	_Field *	self,
		Py_ssize_t	index
	)

Definition at line 611 of file mfield.cpp.

References Field< A >::get(), oid_to_element(), and RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getItem");
    }
    int len = Field<unsigned int>::get(self->myoid, "numField");
    assert(len >= 0);
    if (index >= len)
    {
        PyErr_SetString(PyExc_IndexError, "moose.ElementField.getItem: index out of bounds.");
        return NULL;
    }
    if (index < 0)
    {
        index += len;
    }
    if (index < 0)
    {
        PyErr_SetString(PyExc_IndexError, "moose.ElementField.getItem: invalid index.");
        return NULL;
    }
    // _ObjId * oid = PyObject_New(_ObjId, &ObjIdType);
    // cout << "Element field: " << self->name << ", owner: " << self->owner->oid_.path() << endl;
    // stringstream path;
    // path << self->owner->oid_.path() << "/" << self->name << "[" << index << "]";
    // cout << "moose_ElementField_getItem:: path=" << path.str();
    // oid->oid_ = ObjId(self->myoid.id, self->myoid.dataIndex, index);
    // return (PyObject*)oid;
    ObjId oid(self->myoid.id, self->myoid.dataIndex, index);
    return oid_to_element(oid);
}

Here is the call graph for this function:

Py_ssize_t moose_ElementField_getLen	(	_Field *	self,
		void *	closure
	)

Definition at line 561 of file mfield.cpp.

References Field< A >::get(), and RAISE_INVALID_ID.

Referenced by moose_ElementField_setattro().

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_getLen");
    }
    unsigned int num = Field<unsigned int>::get(self->myoid, "numField");
    return Py_ssize_t(num);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ElementField_getName	(	_Field *	self,
		void *	closure
	)

Definition at line 593 of file mfield.cpp.

{
    return Py_BuildValue("s", self->name);
}

PyObject* moose_ElementField_getNum	(	_Field *	self,
		void *	closure
	)

Definition at line 528 of file mfield.cpp.

References Field< A >::get(), and RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getNum");
    }
    string name = self->name;
    name[0] = std::toupper( name[0] );
    unsigned int num = Field<unsigned int>::get(self->myoid, "numField");
    return Py_BuildValue("I", num);
}

Here is the call graph for this function:

PyObject* moose_ElementField_getOwner	(	_Field *	self,
		void *	closure
	)

Definition at line 597 of file mfield.cpp.

{
    Py_INCREF(self->owner);
    return (PyObject*)self->owner;
}

PyObject* moose_ElementField_getPath	(	_Field *	self,
		void *	closure
	)

Definition at line 571 of file mfield.cpp.

References Id::isValid(), path, and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_setNum");
    }
    string path = Id(self->owner->oid_.path() + "/" + string(self->name)).path();
    return Py_BuildValue("s", path.c_str());
}

Here is the call graph for this function:

PyObject* moose_ElementField_getSlice	(	_Field *	self,
		Py_ssize_t	start,
		Py_ssize_t	end
	)

Definition at line 644 of file mfield.cpp.

References Field< A >::get(), oid_to_element(), RAISE_INVALID_ID, and value.

{
    assert(start >= 0);
    assert(end >= 0);

    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ElementField_getSlice");
    }
    Py_ssize_t len = Field<unsigned int>::get(self->myoid, "numField");
    while (start < 0)
    {
        start += len;
    }
    while (end < 0)
    {
        end += len;
    }
    if (start > end)
    {
        // PyErr_SetString(PyExc_IndexError, "Start index must be less than end.");
        // return NULL;
        // Python itself returns empty tuple in such cases, follow that
        return PyTuple_New(0);
    }
    PyObject * ret = PyTuple_New((Py_ssize_t)(end - start));
    for ( int ii = start; ii < end; ++ii)
    {
        ObjId oid(self->myoid.id, self->myoid.dataIndex, ii);
        PyObject * value = oid_to_element(oid);
        if (PyTuple_SetItem(ret, (Py_ssize_t)(ii-start), value))
        {
            Py_XDECREF(ret);
            // Py_XDECREF(value);
            PyErr_SetString(PyExc_RuntimeError, "Could not assign tuple entry.");
            return NULL;
        }
    }
    return ret;
}

Here is the call graph for this function:

int moose_ElementField_init	(	_Field *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Initialize field with ObjId and fieldName.

Definition at line 519 of file mfield.cpp.

References moose_Field_init().

{
    moose_Field_init(self, args, kwargs);
    string path = self->owner->oid_.path()+"/";
    path += string(self->name);
    self->myoid = ObjId(path);
    return 0;
}

Here is the call graph for this function:

int moose_ElementField_setattro	(	_Field *	self,
		PyObject *	attr,
		PyObject *	value
	)

Definition at line 826 of file mfield.cpp.

References Field< A >::get(), getFieldType(), Id::isValid(), moose_ElementField_getLen(), RAISE_INVALID_ID, Field< A >::setVec(), shortType(), and value.

{
    if (!Id::isValid(self->myoid))
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_setattro");
    }
    int ret = -1;
    string field;
    if (PyString_Check(attr))
    {
        field = string(PyString_AsString(attr));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Attribute name must be a string");
        return -1;
    }
    string moose_class = Field<string>::get(self->myoid, "className");
    string fieldtype = getFieldType(moose_class, field);
    if (fieldtype.length() == 0)
    {
        if (field == "num")
        {
            return PyObject_GenericSetAttr((PyObject*)self, attr, value);
        }
        PyErr_SetString(PyExc_AttributeError, "cannot add new field to ElementField objects");
        return -1;
    }
    char ftype = shortType(fieldtype);
    Py_ssize_t length = moose_ElementField_getLen(self, NULL);
    bool is_seq = true;
    if (!PySequence_Check(value))
    {
        is_seq = false;
    }
    else if (length != PySequence_Length(value))
    {
        PyErr_SetString(PyExc_IndexError, "Length of the sequence on the right hand side does not match Id size.");
        return -1;
    }

    assert(length >= 0);
    switch(ftype)
    {
    case 'd':  //SET_VECFIELD(double, d)
    {
        vector<double> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                double v = PyFloat_AsDouble(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            double v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<double>::setVec(self->myoid, field, _value);
        break;
    }
    case 's':
    {
        vector<string> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                char * v = PyString_AsString(PySequence_GetItem(value, ii));
                _value.push_back(string(v));
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            _value.assign(length, string(v));
        }
        ret = Field<string>::setVec(self->myoid, field, _value);
        break;
    }
    case 'i':
    {
        vector<int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                int v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            int v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< int >::setVec(self->myoid, field, _value);
        break;
    }
    case 'I':  //SET_VECFIELD(unsigned int, I)
    {
        vector<unsigned int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                unsigned int v = PyInt_AsUnsignedLongMask(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            unsigned int v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned int >::setVec(self->myoid, field, _value);
        break;
    }
    case 'l':  //SET_VECFIELD(long, l)
    {
        vector<long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                long v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            long v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field<long>::setVec(self->myoid, field, _value);
        break;
    }
    case 'k':  //SET_VECFIELD(unsigned long, k)
    {
        vector<unsigned long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                unsigned long v = PyInt_AsUnsignedLongMask(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            unsigned long v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned long >::setVec(self->myoid, field, _value);
        break;
    }
    case 'b':
    {
        vector<bool> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                bool v = (Py_True ==_v) || (PyInt_AsLong(_v) != 0);
                _value.push_back(v);
            }
        }
        else
        {
            bool v = (Py_True ==value) || (PyInt_AsLong(value) != 0);
            _value.assign(length, v);
        }
        ret = Field< bool >::setVec(self->myoid, field, _value);
        break;
    }
    case 'c':
    {
        vector<char> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                char * v = PyString_AsString(_v);
                if (v && v[0])
                {
                    _value.push_back(v[0]);
                }
                else
                {
                    ostringstream err;
                    err << ii << "-th element is NUL";
                    PyErr_SetString(PyExc_ValueError, err.str().c_str());
                    return -1;
                }
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            if (v && v[0])
            {
                _value.assign(length, v[0]);
            }
            else
            {
                PyErr_SetString(PyExc_ValueError,  "value is an empty string");
                return -1;
            }
        }
        ret = Field< char >::setVec(self->myoid, field, _value);
        break;
    }
    case 'h':
    {
        vector<short> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                short v = PyInt_AsLong(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            short v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< short >::setVec(self->myoid, field, _value);
        break;
    }
    case 'f':  //SET_VECFIELD(float, f)
    {
        vector<float> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                float v = PyFloat_AsDouble(PySequence_GetItem(value, ii));
                _value.push_back(v);
            }
        }
        else
        {
            float v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<float>::setVec(self->myoid, field, _value);
        break;
    }
    default:
        break;
    }
    // MOOSE Field::set returns 1 for success 0 for
    // failure. Python treats return value 0 from setters as
    // success, anything else failure.
    if (ret && (PyErr_Occurred() == NULL))
    {
        return 0;
    }
    else
    {
        return -1;
    }

}

Here is the call graph for this function:

int moose_ElementField_setNum	(	_Field *	self,
		PyObject *	num,
		void *	closure
	)

Definition at line 540 of file mfield.cpp.

References RAISE_INVALID_ID.

{
    if (self->owner->oid_.bad())
    {
        RAISE_INVALID_ID(-1, "moose_ElementField_setNum");
    }
    unsigned int num;
    if (!PyInt_Check(args))
    {
        PyErr_SetString(PyExc_TypeError, "moose.ElementField.setNum - needes an integer.");
        return -1;
    }
    num = PyInt_AsUnsignedLongMask(args);
    if (!Field<unsigned int>::set(self->myoid, "numField", num))
    {
        PyErr_SetString(PyExc_RuntimeError, "moose.ElementField.setNum : Field::set returned False.");
        return -1;
    }
    return 0;
}

PyObject* moose_exists	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1764 of file moosemodule.cpp.

References path.

{
    char * path;
    if (!PyArg_ParseTuple(args, "s", &path))
    {
        return NULL;
    }
    return Py_BuildValue("i", Id(path) != Id() || string(path) == "/" || string(path) == "/root");
}

void moose_Field_dealloc

(

_Field *

self

)

Definition at line 134 of file mfield.cpp.

{
    Py_DECREF(self->owner);
    Py_TYPE(self)->tp_free((PyObject*)self);
}

long moose_Field_hash

(

_Field *

self

)

Return the hash of the string {objectpath}.{fieldName}

Definition at line 142 of file mfield.cpp.

References Id::isValid(), path, and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(-1, "moose_Field_hash");
    }
    string fieldPath = self->owner->oid_.path() + "." + self->name;
    PyObject * path = PyString_FromString(fieldPath.c_str());
    long hash = PyObject_Hash(path);
    Py_XDECREF(path);
    return hash;
}

Here is the call graph for this function:

int moose_Field_init	(	_Field *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Initialize field with ObjId and fieldName.

Definition at line 89 of file mfield.cpp.

References Id::isValid(), ObjIdType, owner, and RAISE_INVALID_ID.

Referenced by moose_ElementField_init().

{
    PyObject * owner;
    char * fieldName;
    if (!PyArg_ParseTuple(args, "Os:moose_Field_init", &owner, &fieldName))
    {
        return -1;
    }
    if (fieldName == NULL)
    {
        PyErr_SetString(PyExc_ValueError, "fieldName cannot be NULL");
        return -1;
    }
    if (owner == NULL)
    {
        PyErr_SetString(PyExc_ValueError, "owner cannot be NULL");
        return -1;
    }
    if (!PyObject_IsInstance(owner, (PyObject*)&ObjIdType))
    {
        PyErr_SetString(PyExc_TypeError, "Owner must be subtype of ObjId");
        return -1;
    }
    if (!Id::isValid(((_ObjId*)owner)->oid_.id))
    {
        Py_DECREF(self);
        RAISE_INVALID_ID(-1, "moose_Field_init");
    }
    self->owner = ((_ObjId*)owner);
    Py_INCREF(self->owner);
    self->name = strdup(fieldName);
    if (!self->name) {
        PyErr_NoMemory();
        return -1;
    }

    // In earlier version I tried to deallocate the existing
    // self->name if it is not NULL. But it turns out that it
    // causes a SIGABRT. In any case it should not be an issue as
    // we can safely assume __init__ will be called only once in
    // this case. The Fields are created only internally at
    // initialization of the MOOSE module.
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Field_repr

(

_Field *

self

)

String representation of fields is {objectpath}.{fieldName}

Definition at line 156 of file mfield.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->owner->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_Field_repr");
    }
    ostringstream fieldPath;
    fieldPath << self->owner->oid_.path() << "." << self->name;
    return PyString_FromString(fieldPath.str().c_str());
}

Here is the call graph for this function:

PyObject* moose_getCwe	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1921 of file moosemodule.cpp.

References oid_to_element(), and SHELLPTR.

{
    if (!PyArg_ParseTuple(args, ":moose_getCwe"))
    {
        return NULL;
    }
    // _Id * cwe = (_Id*)PyObject_New(_Id, &IdType);
    // cwe->id_ = SHELLPTR->getCwe();
    // PyObject * ret = (PyObject*)cwe;
    // return ret;
    return oid_to_element(SHELLPTR->getCwe());
}

Here is the call graph for this function:

PyObject* moose_getField	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 2145 of file moosemodule.cpp.

References Field< A >::get(), ObjId::id, _Id::id_, IdType, Id::isValid(), ObjIdType, _ObjId::oid_, RAISE_INVALID_ID, and value.

{
    PyObject * pyobj;
    const char * field;
    const char * type;
    if (!PyArg_ParseTuple(args, "Oss:moose_getfield", &pyobj, &field, &type))
    {
        return NULL;
    }
    if (!PyObject_IsInstance(pyobj, (PyObject*)&ObjIdType))
    {
        PyErr_SetString(PyExc_TypeError, "moose.getField(element, fieldname, fieldtype): First argument must be an instance of element or its subclass");
        return NULL;
    }
    string fname(field), ftype(type);
    ObjId oid = ((_ObjId*)pyobj)->oid_;
    if (!Id::isValid(oid.id))
    {
        RAISE_INVALID_ID(NULL, "moose_getField");
    }
    // Let us do this version using brute force. Might be simpler than getattro.
    if (ftype == "char")
    {
        char value =Field<char>::get(oid, fname);
        return PyInt_FromLong(value);
    }
    else if (ftype == "double")
    {
        double value = Field<double>::get(oid, fname);
        return PyFloat_FromDouble(value);
    }
    else if (ftype == "float")
    {
        float value = Field<float>::get(oid, fname);
        return PyFloat_FromDouble(value);
    }
    else if (ftype == "int")
    {
        int value = Field<int>::get(oid, fname);
        return PyInt_FromLong(value);
    }
    else if (ftype == "string")
    {
        string value = Field<string>::get(oid, fname);
        return PyString_FromString(value.c_str());
    }
    else if (ftype == "unsigned int" || ftype == "unsigned" || ftype == "uint")
    {
        unsigned int value = Field<unsigned int>::get(oid, fname);
        return PyInt_FromLong(value);
    }
    else if (ftype == "Id")
    {
        _Id * value = (_Id*)PyObject_New(_Id, &IdType);
        value->id_ = Field<Id>::get(oid, fname);
        return (PyObject*) value;
    }
    else if (ftype == "ObjId")
    {
        _ObjId * value = (_ObjId*)PyObject_New(_ObjId, &ObjIdType);
        value->oid_ = Field<ObjId>::get(oid, fname);
        return (PyObject*)value;
    }
    else if (ftype == "vector<int>")
    {
        vector<int> value = Field< vector < int > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            PyObject * entry = Py_BuildValue("i", value[ii]);
            if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, entry))
            {
                Py_XDECREF(ret);
                ret = NULL;
                break;
            }
        }
        return ret;
    }
    else if (ftype == "vector<double>")
    {
        vector<double> value = Field< vector < double > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            PyObject * entry = Py_BuildValue("f", value[ii]);
            if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, entry))
            {
                Py_XDECREF(ret);
                ret = NULL;
                break;
            }
        }
        return ret;
    }
    else if (ftype == "vector<float>")
    {
        vector<float> value = Field< vector < float > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            PyObject * entry = Py_BuildValue("f", value[ii]);
            if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, entry))
            {
                Py_XDECREF(ret);
                ret = NULL;
                break;
            }
        }
        return ret;
    }
    else if (ftype == "vector<string>")
    {
        vector<string> value = Field< vector < string > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            PyObject * entry = Py_BuildValue("s", value[ii].c_str());
            if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, entry))
            {
                Py_XDECREF(ret);
                return NULL;
            }
        }
        return ret;
    }
    else if (ftype == "vector<Id>")
    {
        vector<Id> value = Field< vector < Id > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            _Id * entry = PyObject_New(_Id, &IdType);
            entry->id_ = value[ii];
            if (PyTuple_SetItem(ret, (Py_ssize_t)ii, (PyObject*)entry))
            {
                Py_XDECREF(ret);
                return NULL;
            }
        }
        return ret;
    }
    else if (ftype == "vector<ObjId>")
    {
        vector<ObjId> value = Field< vector < ObjId > >::get(oid, fname);
        PyObject * ret = PyTuple_New((Py_ssize_t)value.size());

        for (unsigned int ii = 0; ii < value.size(); ++ ii )
        {
            _ObjId * entry = PyObject_New(_ObjId, &ObjIdType);
            entry->oid_ = value[ii];
            if (PyTuple_SetItem(ret, (Py_ssize_t)ii, (PyObject*)entry))
            {
                Py_XDECREF(ret);
                return NULL;
            }
        }
        return ret;
    }
    PyErr_SetString(PyExc_TypeError, "Field type not handled.");
    return NULL;
}

Here is the call graph for this function:

PyObject* moose_getFieldDict	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 2081 of file moosemodule.cpp.

References getFieldDict(), and value.

{
    char * className = NULL;
    char * fieldType = NULL;
    if (!PyArg_ParseTuple(args, "s|s:moose_getFieldDict", &className, &fieldType))
    {
        return NULL;
    }
    if (!className || (strlen(className) <= 0))
    {
        PyErr_SetString(PyExc_ValueError, "Expected non-empty class name.");
        return NULL;
    }

    Id classId = Id("/classes/" + string(className));
    if (classId == Id())
    {
        string msg = string(className);
        msg += " not a valid MOOSE class.";
        PyErr_SetString(PyExc_NameError, msg.c_str());
        return NULL;
    }
    static const char * finfoTypes [] = {"valueFinfo", "lookupFinfo", "srcFinfo", "destFinfo", "sharedFinfo", NULL};
    vector <string> fields, types;
    if (fieldType && strlen(fieldType) > 0)
    {
        if (getFieldDict(className, string(fieldType), fields, types) == 0)
        {
            PyErr_SetString(PyExc_ValueError, "Invalid finfo type.");
            return NULL;
        }
    }
    else
    {
        for (const char ** ptr = finfoTypes; *ptr != NULL; ++ptr)
        {
            if (getFieldDict(className, string(*ptr), fields, types) == 0)
            {
                string message = "No such finfo type: ";
                message += string(*ptr);
                PyErr_SetString(PyExc_ValueError, message.c_str());
                return NULL;
            }
        }
    }
    PyObject * ret = PyDict_New();
    if (!ret)
    {
        PyErr_SetString(PyExc_SystemError, "Could not allocate dictionary object.");
        return NULL;
    }
    for (unsigned int ii = 0; ii < fields.size(); ++ ii)
    {
        PyObject * value = Py_BuildValue("s", types[ii].c_str());
        if (value == NULL || PyDict_SetItemString(ret, fields[ii].c_str(), value) == -1)
        {
            Py_XDECREF(ret);
            Py_XDECREF(value);
            return NULL;
        }
    }
    return ret;
}

Here is the call graph for this function:

int moose_Id_contains	(	_Id *	self,
		PyObject *	args
	)

Definition at line 799 of file vec.cpp.

References ObjId_SubtypeCheck, and ObjIdType.

{
    extern PyTypeObject ObjIdType;
    int ret = 0;
    if (ObjId_SubtypeCheck(obj))
    {
        ret = (((_ObjId*)obj)->oid_.id == self->id_);
    }
    return ret;
}

PyObject* moose_Id_delete

(

_Id *

self

)

Definition at line 534 of file vec.cpp.

References deleteObjId(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (self->id_ == Id())
    {
        PyErr_SetString(PyExc_ValueError, "moose_Id_delete: cannot delete moose shell.");
        return NULL;
    }
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_delete");
    }
    deleteObjId(self->id_);
    self->id_ = Id();
    Py_CLEAR(self);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_Id_getattro	(	_Id *	self,
		PyObject *	attr
	)

Definition at line 810 of file vec.cpp.

References Field< A >::get(), get_field_alias(), get_Id_attr(), getFieldType(), Field< A >::getVec(), Id::isValid(), RAISE_INVALID_ID, shortType(), and to_pytuple().

{
    int new_attr = 0;
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_getattro");
    }
    char * field = PyString_AsString(attr);
    PyObject * _ret = get_Id_attr(self, field);
    if (_ret != NULL)
    {
        return _ret;
    }
    string className = Field<string>::get(self->id_, "className");
    string type = getFieldType(className, string(field));
    if (type.empty())
    {
        // Check if this field name is aliased and update fieldname and type if so.
        map<string, string>::const_iterator it = get_field_alias().find(string(field));
        if (it != get_field_alias().end())
        {
            field = const_cast<char*>((it->second).c_str());
            type = getFieldType(Field<string>::get(self->id_, "className"), it->second);
            // Update attr for next level (PyObject_GenericGetAttr) in case.
            // Py_XDECREF(attr);
            attr = PyString_FromString(field);
            new_attr = 1;
        }
    }
    if (type.empty())
    {
        return PyObject_GenericGetAttr((PyObject*)self, attr);
    }
    char ftype = shortType(type);
    if (!ftype)
    {
        return PyObject_GenericGetAttr((PyObject*)self, attr);
    }

    switch (ftype)
    {
    case 'd':
    {
        vector < double > val;
        Field< double >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 's':
    {
        vector < string > val;
        Field< string >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'l':
    {
        vector < long > val;
        Field< long >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'x':
    {
        vector < Id > val;
        Field< Id >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'y':
    {
        vector < ObjId > val;
        Field< ObjId >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'i':
    {
        vector < int > val;
        Field< int >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'I':
    {
        vector < unsigned int > val;
        Field< unsigned int >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'k':
    {
        vector < unsigned long > val;
        Field< unsigned long >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'f':
    {
        vector < float > val;
        Field< float >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'b':
    {
        vector<bool> val;
        Field< bool >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'c':
    {
        vector < char > val;
        Field< char >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'h':
    {
        vector < short > val;
        Field< short >::getVec(self->id_, string(field), val);
        _ret = to_pytuple(&val, ftype);
        break;
    }
    case 'z':
    {
        PyErr_SetString(PyExc_NotImplementedError,
                        "moose_Id_getattro: DataId handling not implemented yet.");
        _ret = NULL;
        break;
    }
    default:
        ostringstream msg;
        msg << "moose_Id_getattro: unhandled field type '" << type << "'\n"
            << "This is a vec object. Perhaps you are trying to access the field in an"
            << " element in this. Then use indexing to get the element first.";
        PyErr_SetString(PyExc_ValueError, msg.str().c_str());
        _ret = NULL;
        break;
    }
    if (new_attr)
    {
        Py_DECREF(attr);
    }
    return _ret;
}

Here is the call graph for this function:

PyObject* moose_Id_getItem	(	_Id *	self,
		Py_ssize_t	index
	)

Definition at line 649 of file vec.cpp.

References Id::isValid(), moose_Id_getLength(), oid_to_element(), and RAISE_INVALID_ID.

Referenced by moose_Id_subscript().

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_getItem");
    }
    if (index < 0)
    {
        index += moose_Id_getLength(self);
    }
    if ((index < 0) || (index >= moose_Id_getLength(self)))
    {
        PyErr_SetString(PyExc_IndexError, "index out of bounds.");
        return NULL;
    }
    ObjId oid(self->id_.path()); // This is just to get the dataIndex of parent
    if (self->id_.element()->hasFields())
    {
        // How to efficiently get the dataIndex of parent element
        // without creating ObjId from path?
        oid = ObjId(self->id_, oid.dataIndex, index);
    }
    else
    {
        oid = ObjId(self->id_, index, 0);
    }
    return oid_to_element(oid);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Py_ssize_t moose_Id_getLength

(

_Id *

self

)

Definition at line 607 of file vec.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

Referenced by moose_Id_getItem(), moose_Id_getSlice(), moose_Id_setattro(), and moose_Id_subscript().

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(-1, "moose_Id_getLength");
    }
    if (self->id_.element()->hasFields())
    {
        return (Py_ssize_t)(Field < unsigned int >::get(self->id_, "numField"));
    }
    else
    {
        return (Py_ssize_t)(self->id_.element()->numData());
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Id_getPath

(

_Id *

self

)

Not to be redone. 2011-03-23 14:42:48 (+0530)

Definition at line 588 of file vec.cpp.

References moose::endswith(), Id::isValid(), path, and RAISE_INVALID_ID.

Referenced by get_Id_attr().

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_getPath");
    }
    string path = self->id_.path();
    string default_end("[0]");
    if (moose::endswith(path, default_end))
    {
        path.erase(path.length() - default_end.length(), default_end.length());
    }
    PyObject * ret = Py_BuildValue("s", path.c_str());
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Id_getShape

(

_Id *

self

)

Definition at line 623 of file vec.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

Referenced by get_Id_attr().

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_getShape");
    }
    unsigned int numData = 1;
    if (self->id_.element()->hasFields())
    {
        numData = Field < unsigned int >::get(self->id_, "numField");
    }
    else
    {
        //            numData = Field < unsigned int >::get(self->id_, "numData");
        numData = self->id_.element()->numData();
    }
    PyObject * ret = PyTuple_New((Py_ssize_t)1);
    if (PyTuple_SetItem(ret, (Py_ssize_t)0, Py_BuildValue("I", numData)))
    {
        Py_XDECREF(ret);
        PyErr_SetString(PyExc_RuntimeError, "moose_Id_getShape: could not set tuple entry.");
        return NULL;
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Id_getSlice	(	_Id *	self,
		Py_ssize_t	start,
		Py_ssize_t	end
	)

Definition at line 702 of file vec.cpp.

References Id::isValid(), moose_Id_fillSlice(), moose_Id_getLength(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_getSlice");
    }
    Py_ssize_t len = moose_Id_getLength(self);
    while (start < 0)
    {
        start += len;
    }
    while (end < 0)
    {
        end += len;
    }
    return moose_Id_fillSlice(self, start, end, 1, std::max(end - start, (Py_ssize_t) 0));
}

Here is the call graph for this function:

PyObject* moose_Id_getValue

(

_Id *

self

)

Definition at line 578 of file vec.cpp.

Referenced by get_Id_attr().

{
    unsigned int id = self->id_.value();
    PyObject * ret = Py_BuildValue("I", id);
    return ret;
}

Here is the caller graph for this function:

long moose_Id_hash

(

_Id *

self

)

Definition at line 509 of file vec.cpp.

{
    return self->id_.value(); // hash is the same as the Id value
}

int moose_Id_init	(	_Id *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 416 of file vec.cpp.

References create_Id_from_path(), Id_SubtypeCheck, IdType, ObjId_SubtypeCheck, path, and moose::trim().

{
    extern PyTypeObject IdType;
    PyObject * src = NULL;
    unsigned int id = 0;
    unsigned int isGlobal = 0;
    char * type = NULL;
    // first try parsing the arguments as (path, size, classname)
    static char _path[] = "path";
    static char _dtype[] = "dtype";
    static char _size[] = "n";
    static char _global[] = "g";
    static char * kwlist[] = {_path, _size,  _global, _dtype, NULL};
    char * path = NULL;
    char _default_type[] = "Neutral";
    // set it to 0 for unspecified value in case the user tries to
    // get an existing id without specifying it. If the user is
    // specifying it but the existing vec does not have same
    // numData we warn the user about the misconception. If it is
    // nonexisting vec, we change the unspecifed numData to 1.
    unsigned int numData = 0;
    // char *type = _default_type;
    /* The expected arguments are:
       string path,
       [unsigned int numData] - default: 1
       [unsigned int isGlobal] - default: 0
       [string type] - default: Neutral
    */
    if (PyArg_ParseTupleAndKeywords(args, kwargs, "s|IIs:moose_Id_init",
                                    kwlist, &path, &numData, &isGlobal,
                                    &type)
            )
    {
        // Parsing args successful, if any error happens now,
        // different argument processing will not help. Return error
        string trimmed_path(path);
        trimmed_path = moose::trim(trimmed_path);
        size_t length = trimmed_path.length();
        if (length <= 0)
        {
            PyErr_SetString(PyExc_ValueError,
                            "moose_Id_init: path must be non-empty string.");
            return -1;
        }
        self->id_ = Id(trimmed_path);

        // Return already existing object
        if (self->id_ != Id() || trimmed_path == "/" || trimmed_path == "/root")
        {
            if ((numData > 0) && (numData != Field<unsigned int>::get(self->id_, "numData")))
            {
                PyErr_WarnEx(NULL, "moose_Id_init_: Length specified does not match that of existing object.", 1);
            }
            return 0;
        }
        if (type == NULL)
            type = _default_type;
        if (numData <= 0)
            numData = 1;

        self->id_ = create_Id_from_path(trimmed_path, numData, isGlobal, type);
        if (self->id_ == Id() && PyErr_Occurred())
        {
            return -1;
        }
        return 0;
    }
    // The arguments could not be parsed as (path, dims, class),
    // try to parse it as an existing Id
    PyErr_Clear();
    if (PyArg_ParseTuple(args, "O:moose_Id_init", &src) && Id_SubtypeCheck(src))
    {
        self->id_ = ((_Id*)src)->id_;
        return 0;
    }
    // The arguments could not be parsed as (path, dims, class), or Id
    // try to parse it as an existing ObjId
    PyErr_Clear();
    if (PyArg_ParseTuple(args, "O:moose_Id_init", &src) && ObjId_SubtypeCheck(src))
    {
        self->id_ = ((_ObjId*)src)->oid_.id;
        return 0;
    }
    // Next try to parse it as an integer value for an existing Id
    PyErr_Clear(); // clear the error from parsing error
    if (PyArg_ParseTuple(args, "I:moose_Id_init", &id))
    {
        self->id_ = Id(id);
        return 0;
    }
    return -1;
}// ! moose_Id_init

Here is the call graph for this function:

PyObject* moose_Id_repr

(

_Id *

self

)

Definition at line 551 of file vec.cpp.

References Field< A >::get(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_repr");
    }
    ostringstream repr;
    repr << "<moose.vec: class="
         << Field<string>::get(self->id_, "className") << ", "
         << "id=" << self->id_.value() << ", "
         << "path=" << self->id_.path() << ">";
    return PyString_FromString(repr.str().c_str());
} // !  moose_Id_repr

Here is the call graph for this function:

PyObject* moose_Id_richCompare	(	_Id *	self,
		PyObject *	args,
		int	op
	)

Definition at line 755 of file vec.cpp.

References Id::id_, and IdType.

{
    extern PyTypeObject IdType;
    bool ret = false;
    Id other_id = ((_Id*)other)->id_;
    if (!self || !other)
    {
        ret = false;
    }
    else if (!PyObject_IsInstance(other, (PyObject*)&IdType))
    {
        ret = false;
    }
    else if (op == Py_EQ)
    {
        ret = self->id_ == other_id;
    }
    else if (op == Py_NE)
    {
        ret = self->id_ != other_id;
    }
    else if (op == Py_LT)
    {
        ret = self->id_ < other_id;
    }
    else if (op == Py_GT)
    {
        ret = other_id < self->id_;
    }
    else if (op == Py_LE)
    {
        ret = (self->id_ < other_id) || (self->id_ == other_id);
    }
    else if (op == Py_GE)
    {
        ret = (other_id < self->id_) || (self->id_ == other_id);
    }
    if (ret)
    {
        Py_RETURN_TRUE;
    }
    Py_RETURN_FALSE;
}

int moose_Id_setattro	(	_Id *	self,
		PyObject *	attr,
		PyObject *	value
	)

Definition at line 977 of file vec.cpp.

References Field< A >::get(), getFieldType(), Id::isValid(), moose_Id_getLength(), RAISE_INVALID_ID, Field< A >::setVec(), shortType(), and value.

Referenced by moose_Id_setField().

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(-1, "moose_Id_setattro");
    }
    char * fieldname = NULL;
    int ret = -1;
    if (PyString_Check(attr))
    {
        fieldname = PyString_AsString(attr);
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "moose_Id_setattro: Attribute name must be a string");
        return -1;
    }
    string moose_class = Field<string>::get(self->id_, "className");
    string fieldtype = getFieldType(moose_class, string(fieldname));
    if (fieldtype.length() == 0)
    {
        // If it is instance of a MOOSE Id then throw
        // error (to avoid silently creating new attributes due to
        // typos). Otherwise, it must have been subclassed in
        // Python. Then we allow normal Pythonic behaviour and
        // consider such mistakes user's responsibility.
        string className = ((PyTypeObject*)PyObject_Type((PyObject*)self))->tp_name;
        if (className != "vec")
        {
            Py_INCREF(attr);
            ret = PyObject_GenericSetAttr((PyObject*)self, attr, value);
            Py_XDECREF(attr);
            return ret;
        }
        ostringstream msg;
        msg << "moose_Id_setattro: '" << moose_class << "' class has no field '" << fieldname << "'" << endl;
        PyErr_SetString(PyExc_AttributeError, msg.str().c_str());
        return -1;
    }
    char ftype = shortType(fieldtype);
    Py_ssize_t length = moose_Id_getLength(self);
    bool is_seq = true;
    if (!PySequence_Check(value))
    {
        is_seq = false;
    }
    else if (length != PySequence_Length(value))
    {
        PyErr_SetString(PyExc_IndexError,
                        "moose_Id_setattro: length of the sequence on the right hand side does not match Id size.");
        return -1;
    }
    switch(ftype)
    {
    case 'd':  //SET_VECFIELD(double, d)
    {
        vector<double> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                double v = PyFloat_AsDouble(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            double v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<double>::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 's':
    {
        vector<string> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                char * v = PyString_AsString(vo);
                Py_XDECREF(v);
                _value.push_back(string(v));
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            _value.assign(length, string(v));
        }
        ret = Field<string>::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'i':
    {
        vector<int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                int v = PyInt_AsLong(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            int v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< int >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'I':  //SET_VECFIELD(unsigned int, I)
    {
        vector<unsigned int> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                unsigned int v = PyInt_AsUnsignedLongMask(vo);
                Py_DECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            unsigned int v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned int >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'l':  //SET_VECFIELD(long, l)
    {
        vector<long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                long v = PyInt_AsLong(vo);
                Py_DECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            long v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field<long>::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'k':  //SET_VECFIELD(unsigned long, k)
    {
        vector<unsigned long> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                unsigned long v = PyInt_AsUnsignedLongMask(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            unsigned long v = PyInt_AsUnsignedLongMask(value);
            _value.assign(length, v);
        }
        ret = Field< unsigned long >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'b':
    {
        vector<bool> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                bool v = (Py_True ==_v) || (PyInt_AsLong(_v) != 0);
                Py_XDECREF(_v);
                _value.push_back(v);
            }
        }
        else
        {
            bool v = (Py_True ==value) || (PyInt_AsLong(value) != 0);
            _value.assign(length, v);
        }
        ret = Field< bool >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'c':
    {
        vector<char> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * _v = PySequence_GetItem(value, ii);
                char * v = PyString_AsString(_v);
                Py_XDECREF(_v);
                if (v && v[0])
                {
                    _value.push_back(v[0]);
                }
                else
                {
                    ostringstream err;
                    err << "moose_Id_setattro:" << ii << "-th element is NUL";
                    PyErr_SetString(PyExc_ValueError, err.str().c_str());
                    return -1;
                }
            }
        }
        else
        {
            char * v = PyString_AsString(value);
            if (v && v[0])
            {
                _value.assign(length, v[0]);
            }
            else
            {
                PyErr_SetString(PyExc_ValueError,  "moose_Id_setattro: value is an empty string");
                return -1;
            }
        }
        ret = Field< char >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'h':
    {
        vector<short> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                short v = PyInt_AsLong(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            short v = PyInt_AsLong(value);
            _value.assign(length, v);
        }
        ret = Field< short >::setVec(self->id_, string(fieldname), _value);
        break;
    }
    case 'f':  //SET_VECFIELD(float, f)
    {
        vector<float> _value;
        if (is_seq)
        {
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                float v = PyFloat_AsDouble(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
        }
        else
        {
            float v = PyFloat_AsDouble(value);
            _value.assign(length, v);
        }
        ret = Field<float>::setVec(self->id_, string(fieldname), _value);
        break;
    }
    default:
        break;
    }
    // MOOSE Field::set returns 1 for success 0 for
    // failure. Python treats return value 0 from setters as
    // success, anything else failure.
    if (ret && (PyErr_Occurred() == NULL))
    {
        return 0;
    }
    else
    {
        return -1;
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_Id_setField	(	_Id *	self,
		PyObject *	args
	)

Definition at line 958 of file vec.cpp.

References Id::isValid(), moose_Id_setattro(), RAISE_INVALID_ID, and value.

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_setField");
    }
    PyObject * field = NULL;
    PyObject * value = NULL;
    if (!PyArg_ParseTuple(args, "OO:moose_Id_setField", &field, &value))
    {
        return NULL;
    }
    if (moose_Id_setattro(self, field, value) == -1)
    {
        return NULL;
    }
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_Id_str

(

_Id *

self

)

Definition at line 566 of file vec.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->id_))
    {
        RAISE_INVALID_ID(NULL, "moose_Id_str");
    }
    return PyString_FromFormat("<moose.vec: class=%s, id=%u, path=%s>",
                               Field<string>::get(self->id_, "className").c_str(),
                               self->id_.value(), self->id_.path().c_str());
} // !  moose_Id_str

Here is the call graph for this function:

PyObject* moose_Id_subscript	(	_Id *	self,
		PyObject *	op
	)

Definition at line 730 of file vec.cpp.

References moose_Id_fillSlice(), moose_Id_getItem(), moose_Id_getLength(), SLICE_OBJ, and value.

{
    if (PySlice_Check(op))
    {
        const Py_ssize_t len = moose_Id_getLength(self);
        Py_ssize_t start, stop, step, slicelength;

        if (PySlice_GetIndicesEx(SLICE_OBJ(op), len, &start, &stop, &step, &slicelength) < 0)
            return NULL;

        return moose_Id_fillSlice(self, start, stop, step, slicelength);
    }

    if (PyInt_Check(op) || PyLong_Check(op))
    {
        Py_ssize_t value = PyInt_AsLong(op);
        return moose_Id_getItem(self, value);
    }
    else
    {
        PyErr_SetString(PyExc_KeyError, "moose_Id_subscript: invalid index.");
        return NULL;
    }
}

Here is the call graph for this function:

PyObject* moose_isRunning	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1759 of file moosemodule.cpp.

References SHELLPTR.

{
    return Py_BuildValue("i", SHELLPTR->isRunning());
}

PyObject* moose_loadModel	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1794 of file moosemodule.cpp.

References _Id::id_, IdType, and SHELLPTR.

{
    char * fname = NULL, * modelpath = NULL, * solverclass = NULL;

    if(!PyArg_ParseTuple(args, "ss|s:moose_loadModel", &fname, &modelpath, &solverclass))
    {
        cout << "here in moose load";
        return NULL;
    }
    _Id * model = (_Id*)PyObject_New(_Id, &IdType);
    if (!solverclass)
    {
        model->id_ = SHELLPTR->doLoadModel(string(fname), string(modelpath));
    }
    else
    {
        model->id_ = SHELLPTR->doLoadModel(string(fname), string(modelpath), string(solverclass));
    }
    if (model->id_ == Id())
    {
        Py_XDECREF(model);
        PyErr_SetString(PyExc_IOError, "could not load model");
        return NULL;
    }
    PyObject * ret = reinterpret_cast<PyObject*>(model);
    return ret;
}

PyObject* moose_LookupField_getItem	(	_Field *	self,
		PyObject *	key
	)

Definition at line 221 of file mfield.cpp.

References getLookupField().

{
    return getLookupField(self->owner->oid_, self->name, key);
}

Here is the call graph for this function:

int moose_LookupField_setItem	(	_Field *	self,
		PyObject *	key,
		PyObject *	value
	)

Definition at line 226 of file mfield.cpp.

References setLookupField().

{
    return setLookupField(self->owner->oid_,
                          self->name, key, value);
}

Here is the call graph for this function:

PyObject* moose_move	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1468 of file moosemodule.cpp.

References ObjId::bad(), Id::id_, IdType, Id::isValid(), ObjIdType, RAISE_INVALID_ID, and SHELLPTR.

{
    PyObject * src, * dest;
    if (!PyArg_ParseTuple(args, "OO:moose_move", &src, &dest))
    {
        return NULL;
    }
    Id _src;
    ObjId _dest;
    if (PyObject_IsInstance(src, (PyObject*)&IdType))
    {
        _src = ((_Id*)src)->id_;
    }
    else if (PyObject_IsInstance(src, (PyObject*)&ObjIdType))
    {
        _src = ((_ObjId*)src)->oid_.id;
    }
    else if (PyString_Check(src))
    {
        _src = Id(PyString_AsString(src));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Source must be instance of vec, element or string.");
        return NULL;
    }
    if (_src == Id())
    {
        PyErr_SetString(PyExc_ValueError, "Cannot make move moose shell.");
        return NULL;
    }
    if (PyObject_IsInstance(dest, (PyObject*)&IdType))
    {
        _dest = ObjId(((_Id*)dest)->id_);
    }
    else if (PyObject_IsInstance(dest, (PyObject*)&ObjIdType))
    {
        _dest = ((_ObjId*)dest)->oid_;
    }
    else if (PyString_Check(dest))
    {
        _dest = ObjId(PyString_AsString(dest));
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "destination must be instance of vec, element or string.");
        return NULL;
    }
    if (!Id::isValid(_src))
    {
        RAISE_INVALID_ID(NULL, "moose_copy: invalid source Id.");
    }
    else if (_dest.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_copy: invalid destination.");
    }
    SHELLPTR->doMove(_src, _dest);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_ObjId_connect	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 2195 of file melement.cpp.

References ObjId::bad(), Id::isValid(), ObjIdType, _ObjId::oid_, RAISE_INVALID_ID, and SHELLPTR.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_connect");
    }
    extern PyTypeObject ObjIdType;
    PyObject * destPtr = NULL;
    char * srcField = NULL, * destField = NULL, * msgType = NULL;
    static char default_msg_type[] = "Single";
    if(!PyArg_ParseTuple(args,
                         "sOs|s:moose_ObjId_connect",
                         &srcField,
                         &destPtr,
                         &destField,
                         &msgType))
    {
        return NULL;
    }
    if (msgType == NULL)
    {
        msgType = default_msg_type;
    }
    _ObjId * dest = reinterpret_cast<_ObjId*>(destPtr);
    ObjId mid = SHELLPTR->doAddMsg(msgType,
                                   self->oid_,
                                   string(srcField),
                                   dest->oid_,
                                   string(destField));
    if (mid.bad())
    {
        PyErr_SetString(PyExc_NameError,
                        "connect failed: check field names and type compatibility.");
        return NULL;
    }
    _ObjId* msgMgrId = (_ObjId*)PyObject_New(_ObjId, &ObjIdType);
    msgMgrId->oid_ = mid;
    return (PyObject*)msgMgrId;
}

Here is the call graph for this function:

PyObject* moose_ObjId_get_destField_attr	(	PyObject *	self,
		void *	closure
	)

Definition at line 2677 of file moosemodule.cpp.

References ObjId::id, Id::isValid(), moose_DestField, name, ObjIdType, _ObjId::oid_, and RAISE_INVALID_ID.

Referenced by defineDestFinfos().

{
    if (!PyObject_IsInstance(self, (PyObject*)&ObjIdType))
    {
        PyErr_SetString(PyExc_TypeError, "First argument must be an instance of element");
        return NULL;
    }
    _ObjId * obj = (_ObjId*)self;
    if (!Id::isValid(obj->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_get_destField_attr");
    }
    char * name = NULL;
    if (!PyArg_ParseTuple((PyObject *)closure,
                          "s:_get_destField: "
                          "expected a string in getter closure.",
                          &name))
    {
        return NULL;
    }
    PyObject * args = PyTuple_New(2);

    PyTuple_SetItem(args, 0, self);
    Py_INCREF(self); // compensate for reference stolen by PyTuple_SetItem
    PyTuple_SetItem(args, 1, PyString_FromString(name));
    _Field * ret = PyObject_New(_Field, &moose_DestField);
    if (moose_DestField.tp_init((PyObject*)ret, args, NULL) != 0)
    {
        Py_XDECREF((PyObject*)ret);
        ret = NULL;
        PyErr_SetString(PyExc_RuntimeError, "moose_ObjId_get_destField_attr: failed to init DestField object");
    }
    Py_DECREF(args);
    return (PyObject*)ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_get_elementField_attr	(	PyObject *	self,
		void *	closure
	)

Definition at line 2822 of file moosemodule.cpp.

References ObjId::id, Id::isValid(), moose_ElementField, name, _ObjId::oid_, and RAISE_INVALID_ID.

Referenced by defineElementFinfos().

{
    // if (!PyObject_IsInstance(self, (PyObject*)&ObjIdType)){
    //       PyErr_SetString(PyExc_TypeError,
    //                       "First argument must be an instance of element");
    //       return NULL;
    //   }
    _ObjId * obj = (_ObjId*)self;
    if (!Id::isValid(obj->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_get_elementField_attr");
    }
    char * name = NULL;
    if (!PyArg_ParseTuple((PyObject *)closure,
                          "s:moose_ObjId_get_elementField_attr: expected a string in getter closure.",
                          &name))
    {
        return NULL;
    }
    // Create a new instance of ElementField `name` and set it as
    // an attribute of the object `self`.
    // 1. Create the argument for init method of ElementField.  This
    //   will be (fieldname, self)
    PyObject * args = PyTuple_New(2);
    PyTuple_SetItem(args, 0, self);
    Py_INCREF(self); // compensate for stolen ref
    PyTuple_SetItem(args, 1, PyString_FromString(name));
    _Field * ret = PyObject_New(_Field, &moose_ElementField);

    // 2. Now use this arg to actually create the element field.
    if (moose_ElementField.tp_init((PyObject*)ret, args, NULL) != 0)
    {
        Py_DECREF((PyObject*)ret);
        ret = NULL;
        PyErr_SetString(PyExc_RuntimeError, "moose_ObjId_get_elementField_attr: failed to init ElementField object");
    }
    Py_DECREF(args);
    return (PyObject*)ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_get_lookupField_attr	(	PyObject *	self,
		void *	closure
	)

Try to obtain a LookupField object for a specified lookupFinfo. The first item in closure must be the name of the LookupFinfo - {fieldname}. The LookupField is identified by {path}.{fieldname} where {path} is the unique path of the moose element self. We look for an already initialized LookupField object for this identifier and return if one is found. Otherwise, we create a new LookupField object and buffer it in a map before returning.

Definition at line 2781 of file moosemodule.cpp.

References ObjId::id, Id::isValid(), moose_LookupField, name, ObjIdType, _ObjId::oid_, and RAISE_INVALID_ID.

Referenced by defineLookupFinfos().

{
    if (!PyObject_IsInstance(self, (PyObject*)&ObjIdType))
    {
        PyErr_SetString(PyExc_TypeError,
                        "First argument must be an instance of element");
        return NULL;
    }
    _ObjId * obj = (_ObjId*)self;
    if (!Id::isValid(obj->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_get_lookupField_attr");
    }
    char * name = NULL;
    if (!PyArg_ParseTuple((PyObject *)closure,
                          "s:moose_ObjId_get_lookupField_attr: expected a string in getter closure.",
                          &name))
    {
        return NULL;
    }
    assert(name);
    /* Create a new instance of LookupField `name` and set it as
     * an attribute of the object self. Create the argument for
     * init method of LookupField.  This will be (fieldname, self) */
    PyObject * args = PyTuple_New(2);
    PyTuple_SetItem(args, 0, self);
    Py_INCREF(self); // compensate for stolen ref
    PyTuple_SetItem(args, 1, PyString_FromString(name));
    _Field * ret = PyObject_New(_Field, &moose_LookupField);
    if (moose_LookupField.tp_init((PyObject*)ret, args, NULL) != 0)
    {
        Py_XDECREF((PyObject*)ret);
        ret = NULL;
        PyErr_SetString(PyExc_RuntimeError,
                        "moose_ObjId_get_lookupField_attr: failed to init LookupField object");
    }
    Py_DECREF(args);
    return (PyObject*)ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getattro	(	_ObjId *	self,
		PyObject *	attr
	)

2011-03-28 13:59:41 (+0530)

Get a specified field. Re-done on: 2011-03-23 14:42:03 (+0530)

I wonder how to cleanly do this. The Id - ObjId dichotomy is really ugly. When you don't pass an index, it is just treated as 0. Then what is the point of having Id separately? ObjId would been just fine!

Definition at line 484 of file melement.cpp.

References Field< A >::get(), get_field_alias(), get_ObjId_attr(), getFieldNames(), getFieldType(), RAISE_INVALID_ID, shortType(), to_py(), and value.

Referenced by moose_ObjId_getField().

{
    int new_attr = 0;
    if (self->oid_.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getattro");
    }
    // extern PyTypeObject IdType;
    // extern PyTypeObject ObjIdType;
    const char * field;
    char ftype;
    if (PyString_Check(attr))
    {
        field = PyString_AsString(attr);
    }
    else
    {
        return PyObject_GenericGetAttr((PyObject*)self, attr);
    }
    PyObject * _ret = get_ObjId_attr(self, field);
    if (_ret != NULL)
    {
        return _ret;
    }
    string fieldName(field);
    string className = Field<string>::get(self->oid_, "className");
    vector<string> valueFinfos = getFieldNames(className, "valueFinfo");
    bool isValueField = false;
    for (unsigned int ii = 0; ii < valueFinfos.size(); ++ii)
    {
        if (fieldName == valueFinfos[ii])
        {
            isValueField = true;
            break;
        }
    }

    string type = getFieldType(className, fieldName);
    if (type.empty() || !isValueField )
    {
        // Check if this field name is aliased and update fieldName and type if so.
        map<string, string>::const_iterator it = get_field_alias().find(fieldName);
        if (it != get_field_alias().end())
        {
            fieldName = it->second;
            field = fieldName.c_str();
            isValueField = false;
            for (unsigned int ii = 0; ii < valueFinfos.size(); ++ii)
            {
                if (fieldName == valueFinfos[ii])
                {
                    isValueField = true;
                    break;
                }
            }
            type = getFieldType(Field<string>::get(self->oid_, "className"), fieldName);
            // Update attr for next level (PyObject_GenericGetAttr) in case.
            // Py_XDECREF(attr);
            attr = PyString_FromString(field);
            new_attr = 1;
        }
    }
    if (type.empty() || !isValueField)
    {
        _ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        if (new_attr)
        {
            Py_DECREF(attr);
        }
        return _ret;
    }
    ftype = shortType(type);
    if (!ftype)
    {
        _ret = PyObject_GenericGetAttr((PyObject*)self, attr);
        if (new_attr)
        {
            Py_DECREF(attr);
        }
        return _ret;
    }
    fieldName= string(field);
    switch(ftype)
    {
    case 's':
    {
        string _s = Field<string>::get(self->oid_, fieldName);
        _ret = Py_BuildValue("s", _s.c_str());
        break;
    }
    case 'd':
    {
        double value = Field< double >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'i':
    {
        int value = Field<int>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'I':
    {
        unsigned int value = Field<unsigned int>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'l':
    {
        long value = Field<long>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'L':
    {
        long long value = Field<long long>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'k':
    {
        unsigned long value = Field<unsigned long>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'K':
    {
        unsigned long long value = Field<unsigned long long>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'f':
    {
        float value = Field<float>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'x':
    {
        Id value = Field<Id>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'y':
    {
        ObjId value = Field<ObjId>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'z':
    {
        PyErr_SetString(PyExc_NotImplementedError, "DataId handling not implemented yet.");
        _ret = NULL;
        break;
    }
    case 'D':
    {
        vector< double > value = Field< vector < double > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'X':   // vector<Id>
    {
        vector < Id > value = Field<vector <Id> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'Y':   // vector<ObjId>
    {
        vector < ObjId > value = Field<vector <ObjId> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'M':
    {
        vector< long > value = Field< vector <long> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'P':
    {
        vector < unsigned long > value = Field< vector < unsigned long > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'S':
    {
        vector < string > value = Field<vector <string> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'v':
    {
        vector < int > value = Field<vector <int> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'N':
    {
        vector <unsigned int > value = Field< vector < unsigned int> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'T':   // vector<vector < unsigned int >>
    {
        vector < vector < unsigned int > > value = Field<vector <vector < unsigned int > > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'Q':   // vector< vector < int > >
    {
        vector <  vector < int >  > value = Field<vector < vector < int > > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'R':   // vector< vector < double > >
    {
        vector <  vector < double >  > value = Field<vector < vector < double > > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'F':
    {
        vector <float> value = Field< vector < float > >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'c':
    {
        char value = Field<char>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'h':
    {
        short value = Field<short>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'H':
    {
        unsigned short value = Field<unsigned short>::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'w':
    {
        vector < short > value = Field<vector <short> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }
    case 'C':
    {
        vector < char > value = Field<vector <char> >::get(self->oid_, fieldName);
        _ret = to_py(&value, ftype);
        break;
    }

    case 'b':
    {
        bool value = Field<bool>::get(self->oid_, fieldName);
        if (value)
        {
            _ret = Py_True;
            Py_INCREF(Py_True);
        }
        else
        {
            _ret = Py_False;
            Py_INCREF(Py_False);
        }
        break;
    }

    default:
        _ret = PyObject_GenericGetAttr((PyObject*)self, attr);

    }
    if (new_attr)
    {
        Py_DECREF(attr);
    }
    return _ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getDataIndex

(

_ObjId *

self

)

Definition at line 2317 of file melement.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

Referenced by get_ObjId_attr().

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getDataIndex");
    }
    PyObject * ret = Py_BuildValue("I", self->oid_.dataIndex);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getField	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 460 of file melement.cpp.

References Id::isValid(), moose_ObjId_getattro(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getField");
    }
    PyObject * attr;
    if (!PyArg_ParseTuple(args, "O:moose_ObjId_getField", &attr))
    {
        return NULL;
    }
    return moose_ObjId_getattro(self, attr);
}

Here is the call graph for this function:

PyObject* moose_ObjId_getFieldIndex

(

_ObjId *

self

)

Definition at line 2330 of file melement.cpp.

References Id::isValid(), and RAISE_INVALID_ID.

Referenced by get_ObjId_attr().

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getFieldIndex");
    }
    PyObject * ret = Py_BuildValue("I", self->oid_.dataIndex);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getFieldNames	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 2047 of file melement.cpp.

References Field< A >::get(), getFieldNames(), getFinfoTypes(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getFieldNames");
    }
    char * ftype = NULL;
    if (!PyArg_ParseTuple(args, "|s:moose_ObjId_getFieldNames", &ftype))
    {
        return NULL;
    }
    string ftype_str = (ftype != NULL)? string(ftype): "";
    vector<string> ret;
    string className = Field<string>::get(self->oid_, "className");
    if (ftype_str == "")
    {
        for (const char **a = getFinfoTypes(); *a; ++a)
        {
            vector<string> fields = getFieldNames(className, string(*a));
            ret.insert(ret.end(), fields.begin(), fields.end());
        }
    }
    else
    {
        ret = getFieldNames(className, ftype_str);
    }

    PyObject * pyret = PyTuple_New((Py_ssize_t)ret.size());

    for (unsigned int ii = 0; ii < ret.size(); ++ ii )
    {
        PyObject * fname = Py_BuildValue("s", ret[ii].c_str());
        if (!fname)
        {
            Py_XDECREF(pyret);
            pyret = NULL;
            break;
        }
        if (PyTuple_SetItem(pyret, (Py_ssize_t)ii, fname))
        {
            Py_XDECREF(pyret);
            // Py_DECREF(fname);
            pyret = NULL;
            break;
        }
    }
    return pyret;
}

Here is the call graph for this function:

PyObject* moose_ObjId_getFieldType	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 420 of file melement.cpp.

References getFieldType(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getFieldType");
    }
    char * fieldName = NULL;
    if (!PyArg_ParseTuple(args, "s:moose_ObjId_getFieldType", &fieldName))
    {
        return NULL;
    }
    string typeStr = getFieldType(Field<string>::get(self->oid_, "className"),
                                  string(fieldName));
    if (typeStr.length() <= 0)
    {
        PyErr_SetString(PyExc_ValueError,
                        "Empty string for field type. "
                        "Field name may be incorrect.");
        return NULL;
    }
    PyObject * type = PyString_FromString(typeStr.c_str());
    return type;
}  // ! moose_Id_getFieldType

Here is the call graph for this function:

PyObject* moose_ObjId_getId

(

_ObjId *

self

)

Definition at line 394 of file melement.cpp.

References _Id::id_, IdType, Id::isValid(), and RAISE_INVALID_ID.

Referenced by get_ObjId_attr().

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getId");
    }
    extern PyTypeObject IdType;
    _Id * ret = PyObject_New(_Id, &IdType);
    ret->id_ = self->oid_.id;
    return (PyObject*)ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getItem	(	_ObjId *	self,
		Py_ssize_t	index
	)

Definition at line 1210 of file melement.cpp.

References moose_ObjId_getLength(), ObjIdType, and _ObjId::oid_.

{
    if (index < 0)
    {
        index += moose_ObjId_getLength(self);
    }
    if ((index < 0) || (index >= moose_ObjId_getLength(self)))
    {
        PyErr_SetString(PyExc_IndexError, "Index out of bounds.");
        return NULL;
    }
    // Here I am assuming the user can start with any ObjId and
    // ask for an index - which will be field index.
    // Thus if syn[0...9] correspond to chan[0...9], then syn[0] is still a valid ObjId.
    // For example, syn has Id X, dataIndex 0...9, and under dataIndex=0, we have 5 field elements f[0...5]
    // Then syn = Id(X)
    // syn[0] = ObjId(X, 0, 0) = syn[0][0]
    // assign s0 <- syn[0]
    // what is s0[1]? ObjId(X
    // syn[0][1]->ObjId(X, 0, 1) =syn[0][0][0] - which is an ObjId.
    // Now, what is syn[0][1][2] ?

    // In PyMOOSE, user is allowed to directly put in the numbers
    // for Id, dataIndex and fieldIndex directly and construct an
    // ObjId.
    _ObjId * ret = PyObject_New(_ObjId, &ObjIdType);
    ret->oid_ = ObjId(self->oid_.id, self->oid_.dataIndex, index);
    return (PyObject*)ret;
}

Here is the call graph for this function:

Py_ssize_t moose_ObjId_getLength

(

_ObjId *

self

)

Definition at line 1276 of file melement.cpp.

References Element::hasFields(), and FieldElement::numData().

Referenced by moose_ObjId_getItem(), and moose_ObjId_getSlice().

{
    Element * el = self->oid_.element();
    if (!el->hasFields())
    {
        return 0;
    }
    FieldElement * fe = reinterpret_cast< FieldElement* >(el);
    if (fe == NULL)
    {
        return 0;
    }
    return (Py_ssize_t)(fe->numData());
}

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_getLookupField	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 1465 of file melement.cpp.

References getLookupField(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getLookupField");
    }
    char * fieldName = NULL;
    PyObject * key = NULL;
    if (!PyArg_ParseTuple(args, "sO:moose_ObjId_getLookupField", &fieldName,  &key))
    {
        return NULL;
    }
    return getLookupField(self->oid_, fieldName, key);
} // moose_ObjId_getLookupField

Here is the call graph for this function:

PyObject* moose_ObjId_getNeighbors	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 2112 of file melement.cpp.

References _Id::id_, IdType, Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_getNeighbors");
    }
    char * field = NULL;
    if (!PyArg_ParseTuple(args, "s:moose_ObjId_getNeighbors", &field))
    {
        return NULL;
    }
    vector< Id > val = LookupField< string, vector< Id > >::get(self->oid_, "neighbors", string(field));

    PyObject * ret = PyTuple_New((Py_ssize_t)val.size());

    for (unsigned int ii = 0; ii < val.size(); ++ ii )
    {
        _Id * entry = PyObject_New(_Id, &IdType);
        if (!entry || PyTuple_SetItem(ret, (Py_ssize_t)ii, (PyObject*)entry))
        {
            Py_DECREF(ret);
            // Py_DECREF((PyObject*)entry);
            ret = NULL;
            break;
        }
        entry->id_ = val[ii];
    }
    return ret;
}

Here is the call graph for this function:

PyObject* moose_ObjId_getSlice	(	_ObjId *	self,
		Py_ssize_t	start,
		Py_ssize_t	end
	)

Definition at line 1240 of file melement.cpp.

References moose_ObjId_getLength(), ObjIdType, _ObjId::oid_, and value.

{
    Py_ssize_t len = moose_ObjId_getLength(self);
    while (start < 0)
    {
        start += len;
    }
    while (end < 0)
    {
        end += len;
    }
    if (start > end)
    {
        // PyErr_SetString(PyExc_IndexError, "Start index must be less than end.");
        // python itself returns empty tuple - follow that
        return PyTuple_New(0);
    }
    PyObject * ret = PyTuple_New((Py_ssize_t)(end - start));

    // Py_XINCREF(ret);
    for ( int ii = start; ii < end; ++ii)
    {
        _ObjId * value = PyObject_New(_ObjId, &ObjIdType);
        value->oid_ = ObjId(self->oid_.id, self->oid_.dataIndex, ii);
        if (PyTuple_SetItem(ret, (Py_ssize_t)(ii-start), (PyObject*)value))  // danger - must we DECREF all prior values?
        {
            Py_XDECREF(ret);
            // Py_XDECREF(value);
            PyErr_SetString(PyExc_RuntimeError, "Failed to assign tuple entry.");
            return NULL;
        }
    }
    return ret;
}

Here is the call graph for this function:

long moose_ObjId_hash

(

_ObjId *

self

)

This function combines Id, DataId and fieldIndex to construct the hash of this object. Here we assume 16 most significant bits for Id, next 32 bits for dataIndex and the least significant 16 bits for fieldIndex. If these criteria are not met, the hash function will cause collissions. Note that the bitshift opeartions are byte order independent - so they should give the same result on both little- and big-endian systems.

Definition at line 333 of file melement.cpp.

References dataIndex, Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(-1, "moose_ObjId_hash");
    }
    long long id = (long long)(self->oid_.id.value());
    long dataIndex = self->oid_.dataIndex;
    long fieldIndex = self->oid_.fieldIndex;
    /* attempt to make it with 32 bit system - assuming id will
     * have its value within least significant 16 bits and
     * dataIndex and fieldIndex will be limited to first 8 bits */
    if (sizeof(size_t) == 8)
    {
        return id << 48 | dataIndex << 16 | fieldIndex;
    }
    else
    {
        return id << 16 | dataIndex << 8 | fieldIndex;
    }
}

Here is the call graph for this function:

int moose_ObjId_init	(	_ObjId *	self,
		PyObject *	args,
		PyObject *	kwargs
	)

Definition at line 296 of file melement.cpp.

References moose::error, moose_ObjId_init_from_id(), and moose_ObjId_init_from_path().

{
    if (self && !PyObject_IsInstance((PyObject*)self, (PyObject*)Py_TYPE((PyObject*)self)))
    {
        ostringstream error;
        error << "Expected an melement or subclass. Found "
              << Py_TYPE(self)->tp_name;
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return -1;
    }
    int ret = moose_ObjId_init_from_path(self, args, kwargs);
    if (ret >= -1)
    {
        return ret;
    }
    // parsing arguments as (path, dims, classname) failed. See if it is existing Id or ObjId.
    if (moose_ObjId_init_from_id(self, args, kwargs) == 0)
    {
        return 0;
    }
    PyErr_SetString(PyExc_ValueError,
                    "Could not parse arguments. "
                    " Call __init__(path, n, g, dtype) or"
                    " __init__(id, dataIndex, fieldIndex)");
    return -1;
}

Here is the call graph for this function:

PyObject* moose_ObjId_repr

(

_ObjId *

self

)

Definition at line 355 of file melement.cpp.

References Field< A >::get(), Id::isValid(), and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_repr");
    }
    ostringstream repr;
    repr << "<moose." << Field<string>::get(self->oid_, "className") << ": "
         << "id=" << self->oid_.id.value() << ", "
         << "dataIndex=" << self->oid_.dataIndex << ", "
         << "path=" << self->oid_.path() << ">";
    return PyString_FromString(repr.str().c_str());
} // !  moose_ObjId_repr

Here is the call graph for this function:

PyObject* moose_ObjId_richcompare	(	_ObjId *	self,
		PyObject *	args,
		int	op
	)

Definition at line 2241 of file melement.cpp.

References moose::error, Id::isValid(), ObjIdType, and RAISE_INVALID_ID.

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_richcompare");
    }
    extern PyTypeObject ObjIdType;
    if ((self != NULL && other == NULL) || (self == NULL && other != NULL))
    {
        if (op == Py_EQ)
        {
            Py_RETURN_FALSE;
        }
        else if (op == Py_NE)
        {
            Py_RETURN_TRUE;
        }
        else
        {
            PyErr_SetString(PyExc_TypeError, "Cannot compare NULL with non-NULL");
            return NULL;
        }
    }
    if (!PyObject_IsInstance(other, (PyObject*)&ObjIdType))
    {
        ostringstream error;
        error << "Cannot compare ObjId with "
              << Py_TYPE(other)->tp_name;
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return NULL;
    }
    if (!Id::isValid(((_ObjId*)other)->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_richcompare");
    }

    string l_path = self->oid_.path();
    string r_path = ((_ObjId*)other)->oid_.path();
    int result = l_path.compare(r_path);
    if (result == 0)
    {
        if (op == Py_EQ || op == Py_LE || op == Py_GE)
        {
            Py_RETURN_TRUE;
        }
        Py_RETURN_FALSE;
    }
    else if (result < 0)
    {
        if (op == Py_LT || op == Py_LE || op == Py_NE)
        {
            Py_RETURN_TRUE;
        }
        Py_RETURN_FALSE;
    }
    else
    {
        if (op == Py_GT || op == Py_GE || op == Py_NE)
        {
            Py_RETURN_TRUE;
        }
        Py_RETURN_FALSE;
    }
}

Here is the call graph for this function:

int moose_ObjId_setattro	(	_ObjId *	self,
		PyObject *	attr,
		PyObject *	value
	)

Set a specified field. Redone on 2011-03-23 14:41:45 (+0530)

Definition at line 809 of file melement.cpp.

References get_moose_classes(), getFieldType(), Id::id_, Id::isValid(), RAISE_INVALID_ID, Field< A >::set(), shortType(), to_cpp(), and value.

Referenced by moose_ObjId_setField().

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(-1, "moose_ObjId_setattro");
    }
    const char * field;
    if (PyString_Check(attr))
    {
        field = PyString_AsString(attr);
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Attribute name must be a string");
        return -1;
    }
    string fieldtype = getFieldType(Field<string>::get(self->oid_, "className"), string(field));
    if (fieldtype.length() == 0)
    {
        // If it is instance of a MOOSE built-in class then throw
        // error (to avoid silently creating new attributes due to
        // typos). Otherwise, it must have been subclassed in
        // Python. Then we allow normal Pythonic behaviour and
        // consider such mistakes user's responsibility.
        string className = ((PyTypeObject*)PyObject_Type((PyObject*)self))->tp_name;
        if (get_moose_classes().find(className) == get_moose_classes().end())
        {
            return PyObject_GenericSetAttr((PyObject*)self, PyString_FromString(field), value);
        }
        ostringstream msg;
        msg << "'" << className << "' class has no field '" << field << "'" << endl;
        PyErr_SetString(PyExc_AttributeError, msg.str().c_str());
        return -1;
    }
    char ftype = shortType(fieldtype);
    int ret = 0;
    switch(ftype)
    {
    case 'd':
    {
        double _value = PyFloat_AsDouble(value);
        ret = Field<double>::set(self->oid_, string(field), _value);
        break;
    }
    case 'l':
    {
        long _value = PyInt_AsLong(value);
        if ((_value != -1) || (!PyErr_Occurred()))
        {
            ret = Field<long>::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'I':
    {
        unsigned long _value = PyInt_AsUnsignedLongMask(value);
        ret = Field<unsigned int>::set(self->oid_, string(field), (unsigned int)_value);
        break;
    }
    case 'k':
    {
        unsigned long _value = PyInt_AsUnsignedLongMask(value);
        ret = Field<unsigned long>::set(self->oid_, string(field), _value);
        break;
    }
    case 'f':
    {
        float _value = PyFloat_AsDouble(value);
        ret = Field<float>::set(self->oid_, string(field), _value);
        break;
    }
    case 's':
    {
        char * _value = PyString_AsString(value);
        if (_value)
        {
            ret = Field<string>::set(self->oid_, string(field), string(_value));
        }
        break;
    }
    case 'x':  // Id
    {
        if (value)
        {
            ret = Field<Id>::set(self->oid_, string(field), ((_Id*)value)->id_);
        }
        else
        {
            PyErr_SetString(PyExc_ValueError, "Null pointer passed as vec Id value.");
            return -1;
        }
        break;
    }
    case 'y':  // ObjId
    {
        if (value)
        {
            ret = Field<ObjId>::set(self->oid_, string(field), ((_ObjId*)value)->oid_);
        }
        else
        {
            PyErr_SetString(PyExc_ValueError, "Null pointer passed as vec Id value.");
            return -1;
        }
        break;
    }
    case 'D':  //SET_VECFIELD(double, d)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<double> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<double> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                double v = PyFloat_AsDouble(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < double > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'b':
    {
        bool _value = (Py_True == value) || (PyInt_AsLong(value) != 0);
        ret = Field<bool>::set(self->oid_, string(field), _value);
        break;
    }
    case 'c':
    {
        char * _value = PyString_AsString(value);
        if (_value && _value[0])
        {
            ret = Field<char>::set(self->oid_, string(field), _value[0]);
        }
        break;
    }
    case 'i':
    {
        int _value = PyInt_AsLong(value);
        if ((_value != -1) || (!PyErr_Occurred()))
        {
            ret = Field<int>::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'h':
    {
        short _value = (short)PyInt_AsLong(value);
        if ((_value != -1) || (!PyErr_Occurred()))
        {
            ret = Field<short>::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'z':  // DataId
    {
        PyErr_SetString(PyExc_NotImplementedError, "DataId handling not implemented yet.");
        return -1;
    }
    case 'v':
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<int> field, specified value must be a sequence." );
        }
        Py_ssize_t length = PySequence_Length(value);
        vector<int> _value;
        for ( int ii = 0; ii < length; ++ii)
        {
            PyObject * vo = PySequence_GetItem(value, ii);
            int v = PyInt_AsLong(vo);
            Py_XDECREF(vo);
            _value.push_back(v);
        }
        ret = Field< vector < int > >::set(self->oid_, string(field), _value);
        break;
    }
    case 'w':
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<short> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<short> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                short v = PyInt_AsLong(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < short > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'L':  //SET_VECFIELD(long, l)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError,
                            "For setting vector<long> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<long> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                long v = PyInt_AsLong(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < long > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'N':  //SET_VECFIELD(unsigned int, I)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<unsigned int> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<unsigned int> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                unsigned int v = PyInt_AsUnsignedLongMask(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < unsigned int > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'K':  //SET_VECFIELD(unsigned long, k)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<unsigned long> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<unsigned long> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                unsigned long v = PyInt_AsUnsignedLongMask(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < unsigned long > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'F':  //SET_VECFIELD(float, f)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<float> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<float> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                float v = PyFloat_AsDouble(vo);
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < float > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'S':
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<string> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<string> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                char * v = PyString_AsString(vo);
                Py_XDECREF(vo);
                _value.push_back(string(v));
            }
            ret = Field< vector < string > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'T':  // vector< vector<unsigned int> >
    {
        vector < vector <unsigned> > * _value = (vector < vector <unsigned> > *)to_cpp(value, ftype);
        if (!PyErr_Occurred())
        {
            ret = Field < vector < vector <unsigned> > >::set(self->oid_, string(field), *_value);
        }
        delete _value;
        break;
    }
    case 'Q':  // vector< vector<int> >
    {
        vector < vector <int> > * _value = (vector < vector <int> > *)to_cpp(value, ftype);
        if (!PyErr_Occurred())
        {
            ret = Field < vector < vector <int> > >::set(self->oid_, string(field), *_value);
        }
        delete _value;
        break;
    }
    case 'R':  // vector< vector<double> >
    {
        vector < vector <double> > * _value = (vector < vector <double> > *)to_cpp(value, ftype);
        if (!PyErr_Occurred())
        {
            ret = Field < vector < vector <double> > >::set(self->oid_, string(field), *_value);
        }
        delete _value;
        break;
    }
    case 'X':  //SET_VECFIELD(Id, f)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<Id> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<Id> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                Id v = ((_Id*)vo)->id_;
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < Id > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    case 'Y':  //SET_VECFIELD(ObjId, f)
    {
        if (!PySequence_Check(value))
        {
            PyErr_SetString(PyExc_TypeError, "For setting vector<ObjId> field, specified value must be a sequence." );
        }
        else
        {
            Py_ssize_t length = PySequence_Length(value);
            vector<ObjId> _value;
            for ( int ii = 0; ii < length; ++ii)
            {
                PyObject * vo = PySequence_GetItem(value, ii);
                ObjId v = ((_ObjId*)vo)->oid_;
                Py_XDECREF(vo);
                _value.push_back(v);
            }
            ret = Field< vector < ObjId > >::set(self->oid_, string(field), _value);
        }
        break;
    }
    default:
        break;
    }
    // MOOSE Field::set returns 1 for success 0 for
    // failure. Python treats return value 0 from stters as
    // success, anything else failure.
    if (ret)
    {
        return 0;
    }
    else
    {
        ostringstream msg;
        msg <<  "Failed to set field '"  << field << "'";
        PyErr_SetString(PyExc_AttributeError,msg.str().c_str());
        return -1;
    }
} // moose_ObjId_setattro

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_setDestField	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 1634 of file melement.cpp.

References moose::error, Id::isValid(), maxArgs, minArgs, parseFinfoType(), RAISE_INVALID_ID, SetGet0::set(), setDestFinfo(), setDestFinfo2(), and shortType().

Referenced by moose_DestField_call().

{
    if (!Id::isValid(self->oid_.id))
    {
        RAISE_INVALID_ID(NULL, "moose_ObjId_setDestField");
    }
    PyObject * arglist[10] = {NULL, NULL, NULL, NULL, NULL,
                              NULL, NULL, NULL, NULL, NULL
                             };
    ostringstream error;
    ObjId oid = ((_ObjId*)self)->oid_;

    error << "moose.setDestField: ";
    // Unpack the arguments
    if (!PyArg_UnpackTuple(args, "setDestField", minArgs, maxArgs,
                           &arglist[0], &arglist[1], &arglist[2],
                           &arglist[3], &arglist[4], &arglist[5],
                           &arglist[6], &arglist[7], &arglist[8],
                           &arglist[9]))
    {
        error << "At most " << maxArgs - 1 << " arguments can be handled.";
        PyErr_SetString(PyExc_ValueError, error.str().c_str());
        return NULL;
    }

    // Get the destFinfo name
    char * fieldName = PyString_AsString(arglist[0]);
    if (!fieldName)  // not a string, raises TypeError
    {
        error << "first argument must be a string specifying field name.";
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return NULL;
    }

    // Try to parse the arguments.
    vector< string > argType;
    if (parseFinfoType(Field<string>::get(oid, "className"),
                       "destFinfo", string(fieldName), argType) < 0)
    {
        error << "Arguments not handled: " << fieldName << "(";
        for (unsigned int ii = 0; ii < argType.size(); ++ii)
        {
            error << argType[ii] << ",";
        }
        error << ")";
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return NULL;
    }
    if (argType.size() == 1)
    {
        if ( arglist[1] == NULL && argType[0] == "void")
        {
            bool ret = SetGet0::set(oid, string(fieldName));
            if (ret)
            {
                Py_RETURN_TRUE;
            }
            else
            {
                Py_RETURN_FALSE;
            }
        }
        return setDestFinfo(oid, string(fieldName), arglist[1], argType[0]);
    }
    else if (argType.size() == 2)
    {
        return setDestFinfo2(oid, string(fieldName), arglist[1], shortType(argType[0]), arglist[2], shortType(argType[1]));
    }
    else
    {
        error << "Can handle only up to 2 arguments" << endl;
        return NULL;
    }
} // moose_ObjId_setDestField

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* moose_ObjId_setField	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 791 of file melement.cpp.

References moose_ObjId_setattro(), and value.

{
    PyObject * field;
    PyObject * value;
    if (!PyArg_ParseTuple(args, "OO:moose_ObjId_setField", &field, &value))
    {
        return NULL;
    }
    if (moose_ObjId_setattro(self, field, value) == -1)
    {
        return NULL;
    }
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_ObjId_setLookupField	(	_ObjId *	self,
		PyObject *	args
	)

Definition at line 1600 of file melement.cpp.

References Id::isValid(), setLookupField(), and value.

{
    if (!Id::isValid(self->oid_.id))
    {
        return NULL;
    }
    PyObject * key;
    PyObject * value;
    char * field;
    if (!PyArg_ParseTuple(args, "sOO:moose_ObjId_setLookupField", &field,  &key, &value))
    {
        return NULL;
    }
    if ( setLookupField(self->oid_, field, key, value) == 0)
    {
        Py_RETURN_NONE;
    }
    return NULL;
}// moose_ObjId_setLookupField

Here is the call graph for this function:

PyObject* moose_quit

(

PyObject *

dummy

)

This should not be required or accessible to the user. Put here for debugging threading issue.

Definition at line 2450 of file moosemodule.cpp.

References finalize().

{
    finalize();
    cout << "Quitting MOOSE." << endl;
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_reinit	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1749 of file moosemodule.cpp.

References SHELLPTR.

{
    SHELLPTR->doReinit();
    Py_RETURN_NONE;
}

PyObject* moose_seed	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 2339 of file moosemodule.cpp.

References pymoose_mtseed_().

{
    long int seed = 0;
    if (!PyArg_ParseTuple(args, "|l", &seed))
    {
        return NULL;
    }
    pymoose_mtseed_(seed);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_setClock	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1656 of file moosemodule.cpp.

References SHELLPTR.

{
    unsigned int tick;
    double dt;
    if(!PyArg_ParseTuple(args, "Id:moose_setClock", &tick, &dt))
    {
        return NULL;
    }
    if (dt < 0)
    {
        PyErr_SetString(PyExc_ValueError, "dt must be positive.");
        return NULL;
    }
    SHELLPTR->doSetClock(tick, dt);
    Py_RETURN_NONE;
}

PyObject* moose_setCwe	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1879 of file moosemodule.cpp.

References ObjId::bad(), IdType, ObjIdType, path, RAISE_INVALID_ID, and SHELLPTR.

{
    PyObject * element = NULL;
    char * path = NULL;
    ObjId oid;
    if (PyTuple_Size(args) == 0)
    {
        oid = Id("/");
    }
    else if(PyArg_ParseTuple(args, "s:moose_setCwe", &path))
    {
        oid = ObjId(string(path));
    }
    else if (PyArg_ParseTuple(args, "O:moose_setCwe", &element))
    {
        PyErr_Clear();
        if (PyObject_IsInstance(element, (PyObject*)&IdType))
        {
            oid = (reinterpret_cast<_Id*>(element))->id_;
        }
        else if (PyObject_IsInstance(element, (PyObject*)&ObjIdType))
        {
            oid = (reinterpret_cast<_ObjId*>(element))->oid_;
        }
        else
        {
            PyErr_SetString(PyExc_NameError, "setCwe: Argument must be an vec or element");
            return NULL;
        }
    }
    else
    {
        return NULL;
    }
    if (oid.bad())
    {
        RAISE_INVALID_ID(NULL, "moose_setCwe");
    }
    SHELLPTR->setCwe(oid);
    Py_RETURN_NONE;
}

Here is the call graph for this function:

PyObject* moose_start	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1703 of file moosemodule.cpp.

References handle_keyboard_interrupts(), and SHELLPTR.

{
    double runtime = 0.0;
    bool notify = false;

    PyArg_ParseTuple(args, "d|I:moose_start", &runtime, &notify);

    if (runtime <= 0.0)
    {
        PyErr_SetString(PyExc_ValueError, "simulation runtime must be positive.");
        return NULL;
    }

    // This is from http://stackoverflow.com/questions/1641182/how-can-i-catch-a-ctrl-c-event-c
    struct sigaction sigHandler;
    sigHandler.sa_handler = handle_keyboard_interrupts;
    sigemptyset(&sigHandler.sa_mask);
    sigHandler.sa_flags = 0;
    sigaction(SIGINT, &sigHandler, NULL);

#if 0
    // NOTE: (dilawar) Does not know if Py_BEGIN_ALLOW_THREADS is
    // neccessary.
    // Py_BEGIN_ALLOW_THREADS
    SHELLPTR->doStart(runtime);
    // Py_END_ALLOW_THREADS
    Py_RETURN_NONE;
#endif
    SHELLPTR->doStart( runtime, notify );
    Py_RETURN_NONE;

}

Here is the call graph for this function:

PyObject* moose_stop	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1754 of file moosemodule.cpp.

References SHELLPTR.

{
    SHELLPTR->doStop();
    Py_RETURN_NONE;
}

PyObject* moose_syncDataHandler	(	PyObject *	dummy,
		PyObject *	target
	)

PyObject* moose_useClock	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 1629 of file moosemodule.cpp.

References path, and SHELLPTR.

{
    char * path, * field;
    unsigned int tick;
    if(!PyArg_ParseTuple(args, "Iss:moose_useClock", &tick, &path, &field))
    {
        return NULL;
    }
    SHELLPTR->doUseClock(string(path), string(field), tick);
    Py_RETURN_NONE;
}

PyObject* moose_wildcardFind	(	PyObject *	dummy,
		PyObject *	args
	)

Definition at line 2412 of file moosemodule.cpp.

References oid_to_element(), and wildcardFind().

{
    vector <ObjId> objects;
    char * wildcard_path = NULL;
    if (!PyArg_ParseTuple(args, "s:moose.wildcardFind", &wildcard_path))
    {
        return NULL;
    }
    wildcardFind(string(wildcard_path), objects);
    PyObject * ret = PyTuple_New(objects.size());
    if (ret == NULL)
    {
        PyErr_SetString(PyExc_RuntimeError, "moose.wildcardFind: failed to allocate new tuple.");
        return NULL;
    }

    for (unsigned int ii = 0; ii < objects.size(); ++ii)
    {
        PyObject * entry = oid_to_element(objects[ii]);
        if (!entry)
        {
            Py_XDECREF(ret);
            PyErr_SetString(PyExc_RuntimeError, "moose.wildcardFind: failed to allocate new vec.");
            return NULL;
        }
        if (PyTuple_SetItem(ret, (Py_ssize_t)ii, entry))
        {
            Py_XDECREF(entry);
            Py_XDECREF(ret);
            return NULL;
        }
    }
    return ret;
}

Here is the call graph for this function:

PyObject* oid_to_element

(

ObjId

oid

)

Definition at line 2899 of file moosemodule.cpp.

References Field< A >::get(), get_moose_classes(), and _ObjId::oid_.

Referenced by moose_connect(), moose_element(), moose_ElementField_getItem(), moose_ElementField_getSlice(), moose_getCwe(), moose_Id_fillSlice(), moose_Id_getItem(), and moose_wildcardFind().

{
    string classname = Field<string>::get(oid, "className");
    map<string, PyTypeObject *>::iterator it = get_moose_classes().find(classname);
    if (it == get_moose_classes().end())
    {
        return NULL;
    }
    PyTypeObject * pyclass = it->second;
    _ObjId * new_obj = PyObject_New(_ObjId, pyclass);
    new_obj->oid_ = oid;
    // Py_XINCREF(new_obj);  // why? PyObject_New initializes refcnt to 1
    return (PyObject*)new_obj;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int parseFinfoType	(	string	className,
		string	finfoType,
		string	fieldName,
		vector< string > &	typeVec
	)

vector<int> pysequence_to_dimvec

(

PyObject *

dims

)

Utility function to convert an Python integer or a sequence object into a vector of dimensions

Definition at line 178 of file moosemodule.cpp.

{
    vector <int> vec_dims;
    Py_ssize_t num_dims = 1;
    long dim_value = 1;
    if (dims)
    {
        // First try to use it as a tuple of dimensions
        if (PyTuple_Check(dims))
        {
            num_dims = PyTuple_Size(dims);
            for (Py_ssize_t ii = 0; ii < num_dims; ++ ii)
            {
                PyObject* dim = PyTuple_GetItem(dims, ii);
                dim_value = PyInt_AsLong(dim);
                if ((dim_value == -1) && PyErr_Occurred())
                {
                    return vec_dims;
                }
                vec_dims.push_back((unsigned int)dim_value);
            }
        }
        else if (PyInt_Check(dims))    // 1D array
        {
            dim_value = PyInt_AsLong(dims);
            if (dim_value <= 0)
            {
                dim_value = 1;
            }
            vec_dims.push_back(dim_value);
        }
    }
    else
    {
        vec_dims.push_back(dim_value);
    }
    return vec_dims;
}

template<typename T >

vector< T >* PySequenceToVector	(	PyObject *	seq,
		char	typecode
	)

Convert a Python sequence into a C++ vector. This dynamically allocates the vector and it is the caller's responsibility to free it.

Definition at line 309 of file moosemodule.h.

References moose::error, to_cpp(), and value.

{
    Py_ssize_t length = PySequence_Length(seq);
    vector <T> * ret = new vector<T>((unsigned int)length);
    T * value;
    for (unsigned int ii = 0; ii < length; ++ii)
    {
        PyObject * item = PySequence_GetItem(seq, ii);
        if (item == NULL)
        {
            ostringstream error;
            error << "Item # " << ii << "is NULL";
            PyErr_SetString(PyExc_ValueError, error.str().c_str());
            delete ret;
            return NULL;
        }
        value = (T*)to_cpp(item, typecode);
        Py_DECREF(item); // PySequence_GetItem returns a new reference. Reduce the refcount now.
        if (value == NULL)
        {
            ostringstream error;
            error << "Cannot handle sequence of type " << Py_TYPE(item)->tp_name;
            PyErr_SetString(PyExc_TypeError, error.str().c_str());
            delete ret;
            return NULL;
        }
        ret->at(ii) = *value;
        delete value;
    }
    return ret;
}

Here is the call graph for this function:

template<typename T >

vector< vector < T > >* PySequenceToVectorOfVectors	(	PyObject *	seq,
		char	typecode
	)

Definition at line 342 of file moosemodule.h.

References moose::error.

{
    Py_ssize_t outerLength = PySequence_Length(seq);
    vector < vector <T> > * ret = new vector < vector < T > >((unsigned int) outerLength);
    for (unsigned int ii = 0; ii < outerLength; ++ii)
    {
        PyObject * innerSeq = PySequence_GetItem(seq, ii);
        if (innerSeq == NULL)
        {
            ostringstream error;
            error << "PySequenceToVectorOfVectors: error converting inner sequence " << ii;
            PyErr_SetString(PyExc_ValueError, error.str().c_str());
            delete ret;
            return NULL;
        }
        vector< T > * inner = PySequenceToVector< T >(innerSeq, typecode);
        Py_DECREF(innerSeq);
        if (inner == NULL)
        {
            delete ret;
            return NULL;
        }
        ret->at(ii).assign(inner->begin(), inner->end());
        delete inner;
    }
    return ret;
}

template<class KeyType >

int set_lookup_value	(	const ObjId &	oid,
		string	fname,
		char	value_type_code,
		char	key_type_code,
		PyObject *	key,
		PyObject *	value_obj
	)

Definition at line 486 of file moosemodule.h.

References SET_LOOKUP_VALUE, and to_cpp().

{
    bool success = false;
    KeyType *cpp_key = (KeyType*)to_cpp(key, key_type_code);
    if (cpp_key == NULL)
    {
        return -1;
    }
#define SET_LOOKUP_VALUE( TYPE )                                        \
    {                                                                   \
        TYPE * value = (TYPE*)to_cpp(value_obj, value_type_code);       \
        if (value){                                                     \
            success = LookupField < KeyType, TYPE > ::set(oid, fname, *cpp_key, *value); \
            delete value;                                               \
            delete cpp_key;                                             \
        }                                                               \
        break;                                                          \
    }

    switch (value_type_code)
    {
    case 'b':
        SET_LOOKUP_VALUE(bool)
    case 'c':
        SET_LOOKUP_VALUE(char)
    case 'h':
        SET_LOOKUP_VALUE(short)
    case 'H':
        SET_LOOKUP_VALUE(unsigned short)
    case 'i':
        SET_LOOKUP_VALUE(int)
    case 'I':
        SET_LOOKUP_VALUE(unsigned int)
    case 'l':
        SET_LOOKUP_VALUE(long)
    case 'k':
        SET_LOOKUP_VALUE(unsigned long)
#ifdef HAVE_LONG_LONG
    case 'L':
        SET_LOOKUP_VALUE(long long)
    case 'K':
        SET_LOOKUP_VALUE(unsigned long long);
#endif
    case 'd':
        SET_LOOKUP_VALUE(double)
    case 'f':
        SET_LOOKUP_VALUE(float)
    case 's':
        SET_LOOKUP_VALUE(string)
    case 'x':
        SET_LOOKUP_VALUE(Id)
    case 'y':
        SET_LOOKUP_VALUE(ObjId)
    case 'D':
        SET_LOOKUP_VALUE( vector <double> )
    case 'S':
        SET_LOOKUP_VALUE( vector <string> )
    case 'X':
        SET_LOOKUP_VALUE( vector <Id> )
    case 'Y':
        SET_LOOKUP_VALUE( vector <ObjId> )
    case 'v':
        SET_LOOKUP_VALUE( vector <int> )
    case 'M':
        SET_LOOKUP_VALUE( vector <long> )
    case 'N':
        SET_LOOKUP_VALUE( vector <unsigned int> )
    case 'P':
        SET_LOOKUP_VALUE( vector <unsigned long> )
    case 'F':
        SET_LOOKUP_VALUE( vector <float> )
    case 'w':
        SET_LOOKUP_VALUE( vector <short> )
    case 'C':
        SET_LOOKUP_VALUE( vector <char> )
    default:
        ostringstream err;
        err << "Value type " << value_type_code << " not supported yet.";
        PyErr_SetString(PyExc_TypeError, err.str().c_str());
    }
    if (success)
    {
        return 0;
    }
    else
    {
        return -1;
    }
}

Here is the call graph for this function:

PyObject* setDestFinfo	(	ObjId	obj,
		string	fieldName,
		PyObject *	arg,
		string	argType
	)

template<class A >

PyObject* setDestFinfo1	(	ObjId	obj,
		string	fieldName,
		PyObject *	arg1,
		char	type1,
		A	arg2
	)

Set destFinfo for 2 argument destination field functions.

Definition at line 607 of file moosemodule.h.

References moose::error, Id::id_, _ObjId::oid_, and SetGet2< A1, A2 >::set().

{
    bool ret;
    ostringstream error;
    error << "moose.setDestFinfo1: ";
    switch (type1)
    {
    case 'f':
    case 'd':
    {
        double param = PyFloat_AsDouble(arg1);
        if (type1 == 'f')
        {
            ret = SetGet2<float, A>::set(obj, fieldName, (float)param, arg2);
        }
        else
        {
            ret = SetGet2<double, A>::set(obj, fieldName, param, arg2);
        }
    }
    break;
    case 's':
    {
        char * param = PyString_AsString(arg1);
        ret = SetGet2<string, A>::set(obj, fieldName, string(param), arg2);
    }
    break;
    case 'i':
    case 'l':
    {
        long param = PyInt_AsLong(arg1);
        if (param == -1 && PyErr_Occurred())
        {
            return NULL;
        }
        if (type1 == 'i')
        {
            ret = SetGet2<int, A>::set(obj, fieldName, (int)param, arg2);
        }
        else
        {
            ret = SetGet2<long, A>::set(obj, fieldName, param, arg2);
        }
    }
    break;
    case 'I':
    case 'k':
    {
        unsigned long param =PyLong_AsUnsignedLong(arg1);
        if (PyErr_Occurred())
        {
            return NULL;
        }
        if (type1 == 'I')
        {
            ret = SetGet2< unsigned int, A>::set(obj, fieldName, (unsigned int)param, arg2);
        }
        else
        {
            ret = SetGet2<unsigned long, A>::set(obj, fieldName, param, arg2);
        }
    }
    break;
    case 'x':
    {
        Id param;
        // if (Id_SubtypeCheck(arg1)){
        _Id * id = (_Id*)(arg1);
        if (id == NULL)
        {
            error << "argument should be an vec or an melement";
            PyErr_SetString(PyExc_TypeError, error.str().c_str());
            return NULL;
        }
        param = id->id_;
        // } else if (ObjId_SubtypeCheck(arg)){
        //     _ObjId * oid = (_ObjId*)(arg);
        //     if (oid == NULL){
        //         error << "argument should be an vec or an melement";
        //         PyErr_SetString(PyExc_TypeError, error.str().c_str());
        //         return NULL;
        //     }
        //     param = oid->oid_.id;
        // }
        ret = SetGet2<Id, A>::set(obj, fieldName, param, arg2);
    }
    break;
    case 'y':
    {
        ObjId param;
        // if (Id_SubtypeCheck(arg)){
        //     _Id * id = (_Id*)(arg);
        //     if (id == NULL){
        //         error << "argument should be an vec or an melement";
        //         PyErr_SetString(PyExc_TypeError, error.str().c_str());
        //         return NULL;
        //     }
        //     param = ObjId(id->id_);
        // } else if (ObjId_SubtypeCheck(arg)){
        _ObjId * oid = (_ObjId*)(arg1);
        if (oid == NULL)
        {
            error << "argument should be an vec or an melement";
            PyErr_SetString(PyExc_TypeError, error.str().c_str());
            return NULL;
        }
        param = oid->oid_;
        // }
        ret = SetGet2<ObjId, A>::set(obj, fieldName, param, arg2);
    }
    break;
    case 'c':
    {
        char * param = PyString_AsString(arg1);
        if (!param)
        {
            error << "expected argument of type char/string";
            PyErr_SetString(PyExc_TypeError, error.str().c_str());
            return NULL;
        }
        else if (strlen(param) == 0)
        {
            error << "Empty string not allowed.";
            PyErr_SetString(PyExc_ValueError, error.str().c_str());
            return NULL;
        }
        ret = SetGet2<char, A>::set(obj, fieldName, param[0], arg2);
    }
    default:
    {
        error << "Unhandled argument 1 type (shortType=" << type1 << ")";
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return NULL;
    }
    }
    if (ret)
    {
        Py_RETURN_TRUE;
    }
    else
    {
        Py_RETURN_FALSE;
    }
}

Here is the call graph for this function:

PyObject* setDestFinfo2	(	ObjId	obj,
		string	fieldName,
		PyObject *	arg1,
		char	type1,
		PyObject *	arg2,
		char	type2
	)

int setLookupField	(	ObjId	oid,
		char *	fieldName,
		PyObject *	key,
		PyObject *	value
	)

Definition at line 1480 of file melement.cpp.

References moose::error, Field< A >::get(), parseFinfoType(), shortType(), and value.

Referenced by moose_LookupField_setItem(), and moose_ObjId_setLookupField().

{
    vector<string> type_vec;
    if (parseFinfoType(Field<string>::get(target, "className"), "lookupFinfo", string(fieldName), type_vec) < 0)
    {
        ostringstream error;
        error << "Cannot handle key type for LookupField `" << Field<string>::get(target, "className") << "." << fieldName << "`.";
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
        return -1;
    }
    if (type_vec.size() != 2)
    {
        ostringstream error;
        error << "LookupField type signature should be <keytype>, <valuetype>. But for `"
              << Field<string>::get(target, "className") << "." << fieldName << "` got " << type_vec.size() << " components." ;
        PyErr_SetString(PyExc_AssertionError, error.str().c_str());
        return -1;
    }
    char key_type_code = shortType(type_vec[0]);
    char value_type_code = shortType(type_vec[1]);
    int ret = -1;
    switch(key_type_code)
    {
    case 'I':
    {
        ret = set_lookup_value <unsigned int> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'k':
    {
        ret = set_lookup_value <unsigned long> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 's':
    {
        ret = set_lookup_value <string> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'i':
    {
        ret = set_lookup_value <int> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'l':
    {
        ret = set_lookup_value <long> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'L':
    {
        ret = set_lookup_value <long long> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'K':
    {
        ret = set_lookup_value <unsigned long long> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'b':
    {
        ret = set_lookup_value <bool> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'c':
    {
        ret = set_lookup_value <char> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'h':
    {
        ret = set_lookup_value <short> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'H':
    {
        ret = set_lookup_value <unsigned short> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'd':
    {
        ret = set_lookup_value <double> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'f':
    {
        ret = set_lookup_value <float> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'x':
    {
        ret = set_lookup_value <Id> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    case 'y':
    {
        ret = set_lookup_value <ObjId> (target, string(fieldName), value_type_code, key_type_code, key, value);
        break;
    }
    default:
        ostringstream error;
        error << "setLookupField: invalid key type " << type_vec[0];
        PyErr_SetString(PyExc_TypeError, error.str().c_str());
    }
    return ret;
}// setLookupField

Here is the call graph for this function:

Here is the caller graph for this function:

char shortType

(

string

)

Referenced by getLookupField(), moose_ElementField_getattro(), moose_ElementField_setattro(), moose_Id_getattro(), moose_Id_setattro(), moose_ObjId_getattro(), moose_ObjId_setattro(), moose_ObjId_setDestField(), parseFinfoType(), setDestFinfo(), and setLookupField().

Here is the caller graph for this function:

void* to_cpp	(	PyObject *	object,
		char	typecode
	)

Convert PyObject to C++ object. Returns a pointer to the converted object. Deallocation is caller responsibility

Convert Python object into C++ data structure. The data structure is allocated here and it is the responsibility of the caller to free that memory.

Definition at line 222 of file moosemodule.cpp.

References _Id::id_, _ObjId::oid_, and value.

Referenced by _set_vector_destFinfo(), lookup_value(), moose_ObjId_setattro(), PySequenceToVector(), and set_lookup_value().

{
    switch(typecode)
    {
    case 'i':
    {
        int * ret = new int();
        * ret = PyInt_AsLong(object);
        return (void*)ret;
    }
    case 'l':
    {
        long v = PyInt_AsLong(object);
        long * ret = new long();
        *ret = v;
        return (void*)ret;
    }
    case 'h':
    {
        short v = PyInt_AsLong(object);
        short * ret = new short();
        *ret = v;
        return (void*)ret;
    }
    case 'f':
    {
        float v = (float)PyFloat_AsDouble(object);
        if ( v == -1.0 && PyErr_Occurred())
        {
            PyErr_SetString(PyExc_TypeError, "Expected a sequence of floating point numbers.");
        }
        else
        {
            float * ret = new float();
            *ret = v;
            return (void*)ret;
        }
    }
    case 'd':
    {
        double v = PyFloat_AsDouble(object);
        if ( v == -1.0 && PyErr_Occurred())
        {
            PyErr_SetString(PyExc_TypeError, "Expected a sequence of floating point numbers.");
        }
        else
        {
            double * ret = new double();
            *ret = v;
            return (void*)ret;
        }
    }
    case 's':
    {
        char* tmp = PyString_AsString(object);
        if (tmp == NULL)
        {
            return NULL;
        }
        string * ret = new string(tmp);
        return (void*)ret;
    }
    case 'I':
    {
        unsigned int v = PyInt_AsUnsignedLongMask(object);
        unsigned int * ret = new unsigned int();
        *ret = v;
        return (void*)ret;
    }
    case 'k':
    {
        unsigned long v = PyInt_AsUnsignedLongMask(object);
        unsigned long * ret = new unsigned long();
        *ret = v;
        return (void*)ret;
    }
    case 'x':
    {
        _Id * value = (_Id*)object;
        if (value != NULL)
        {
            Id * ret = new Id();
            * ret = value->id_;
            return (void*)ret;
        }
    }
    case 'y':
    {
        _ObjId * value = (_ObjId*)object;
        if (value != NULL)
        {
            ObjId * ret = new ObjId();
            * ret = value->oid_;
            return (void*)ret;
        }
    }
    case 'v':
        return PySequenceToVector< int >(object, 'i');
    case 'N':
        return PySequenceToVector < unsigned int > (object, 'I');
    case 'w':
        return PySequenceToVector < short > (object, 'h');
    case 'M':
        return PySequenceToVector < long > (object, 'l');
    case 'P':
        return PySequenceToVector < unsigned long > (object, 'k');
    case 'F':
        return PySequenceToVector < float > (object, 'f');
    case 'D':
        return PySequenceToVector < double > (object, 'd');
    case 'S':
        return PySequenceToVector < string > (object, 's');
    case 'Y':
        return PySequenceToVector < ObjId > (object, 'y');
    case 'X':
        return PySequenceToVector < Id > (object, 'x');
    case 'R':
        return PySequenceToVectorOfVectors< double >(object, 'd');
    case 'Q':
        return PySequenceToVectorOfVectors< int >(object, 'i');
    case 'T':
        return PySequenceToVectorOfVectors< unsigned int > (object, 'I');
    }
    return NULL;
}

Here is the caller graph for this function:

PyObject* to_py	(	void *	obj,
		char	typecode
	)

Convert C++ object to Python.

Utility function to convert C++ object into Python object.

Definition at line 352 of file moosemodule.cpp.

References id, IdType, innerType(), ObjIdType, _ObjId::oid_, and to_pytuple().

Referenced by convert_and_set_tuple_entry(), get_simple_lookupfield(), moose_ObjId_getattro(), and test_to_py().

{
    switch(typecode)
    {
    case 'd':
    {
        double * ptr = static_cast<double *>(obj);
        assert(ptr != NULL);
        return PyFloat_FromDouble(*ptr);
    }
    case 's':   // handle only C++ string and NOT C char array because static cast cannot differentiate the two
    {
        string * ptr = static_cast< string * >(obj);
        assert (ptr != NULL);
        return PyString_FromString(ptr->c_str());
    }
    case 'x':
    {
        Id * ptr = static_cast< Id * >(obj);
        assert(ptr != NULL);
        _Id * id = PyObject_New(_Id, &IdType);
        id->id_ = *ptr;
        return (PyObject *)(id);
    }
    case 'y':
    {
        ObjId * ptr = static_cast< ObjId * >(obj);
        assert(ptr != NULL);
        _ObjId * oid = PyObject_New(_ObjId, &ObjIdType);
        oid->oid_ = *ptr;
        return (PyObject*)oid;
    }
    case 'l':
    {
        long * ptr = static_cast< long * >(obj);
        assert(ptr != NULL);
        return PyLong_FromLong(*ptr);
    }
    case 'k':
    {
        unsigned long * ptr = static_cast< unsigned long * >(obj);
        assert(ptr != NULL);
        return PyLong_FromUnsignedLong(*ptr);
    }
    case 'i':  // integer
    {
        int * ptr = static_cast< int * >(obj);
        assert(ptr != NULL);
        return PyInt_FromLong(*ptr);
    }
    case 'I':   // unsigned int
    {
        unsigned int * ptr = static_cast< unsigned int * >(obj);
        assert(ptr != NULL);
        return PyLong_FromUnsignedLong(*ptr);
    }
    case 'b':  //bool
    {
        bool * ptr = static_cast< bool * >(obj);
        assert(ptr != NULL);
        if (*ptr)
        {
            Py_RETURN_TRUE;
        }
        else
        {
            Py_RETURN_FALSE;
        }
    }
#ifdef HAVE_LONG_LONG
    case 'L':   //long long
    {
        long long * ptr = static_cast< long long * > (obj);
        assert(ptr != NULL);
        return PyLong_FromLongLong(*ptr);
    }
    case 'K':   // unsigned long long
    {
        unsigned long long * ptr = static_cast< unsigned long long * >(obj);
        assert(ptr != NULL);
        return PyLong_FromUnsignedLongLong(*ptr);
    }
#endif // HAVE_LONG_LONG
    case 'f':   // float
    {
        float * ptr = static_cast< float* >(obj);
        assert(ptr != NULL);
        return PyFloat_FromDouble(*ptr);
    }
    case 'c':   // char
    {
        char * ptr = static_cast< char * >(obj);
        assert(ptr != NULL);
        return Py_BuildValue("c", *ptr);
    }
    case 'h':   //short
    {
        short * ptr = static_cast< short* >(obj);
        assert(ptr != NULL);
        return Py_BuildValue("h", *ptr);
    }
    case 'H':   // unsigned short
    {
        unsigned short * ptr = static_cast< unsigned short * >(obj);
        assert(ptr != NULL);
        return Py_BuildValue("H", *ptr);
    }
    case 'D':
    case 'v':
    case 'M':
    case 'X':
    case 'Y':
    case 'C':
    case 'w':
    case 'N':
    case 'P':
    case 'F':
    case 'S':
    case 'T':
    case 'Q':
    case 'R':
    {
        return to_pytuple(obj, innerType(typecode));
    }
    default:
    {
        PyErr_SetString(PyExc_TypeError, "unhandled data type");
        return NULL;
    }
    } // switch(typecode)
} // to_py

Here is the call graph for this function:

Here is the caller graph for this function:

PyObject* to_pytuple	(	void *	obj,
		char	typecode
	)

Convert C++ vector to Python tuple

Convert a C++ vector to Python tuple

Definition at line 515 of file moosemodule.cpp.

References convert_and_set_tuple_entry().

Referenced by get_vec_lookupfield(), moose_ElementField_getattro(), moose_Id_getattro(), and to_py().

{
    PyObject * ret;
    switch (typecode)
    {
    case 'd':   // vector<double>
    {
        vector< double > * vec = static_cast< vector < double >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyFloat_FromDouble(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_DOUBLE);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], vec->size() * sizeof(double));
#endif
        return ret;
    }
    case 'i':   // vector<int>
    {
        vector< int > * vec = static_cast< vector < int >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyInt_FromLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_INT);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(int));
#endif
        return ret;
    }
    case 'I':   // vector<unsigned int>
    {
        vector< int > * vec = static_cast< vector < int >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyLong_FromLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_UINT);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(unsigned int));
#endif
        return ret;
    }
    case 'l':   // vector<long>
    {
        vector< long > * vec = static_cast< vector < long >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyLong_FromLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_INT);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(long));
#endif
        return ret;
    }
    case 'x':   // vector<Id>
    {
        vector< Id > * vec = static_cast< vector < Id >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'y':   // vector<ObjId>
    {
        vector< ObjId > * vec = static_cast< vector < ObjId >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'c':   // vector<char>
    {
        vector< char > * vec = static_cast< vector < char >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'h':   // vector<short>
    {
        vector< short > * vec = static_cast< vector < short >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'k':   // vector<unsigned long>
    {
        vector< unsigned int > * vec = static_cast< vector < unsigned int >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyLong_FromUnsignedLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_UINT);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(unsigned int));
#endif
        return ret;
    }
    case 'L':   // vector<long long> - this is not used at present
    {
        vector< long long> * vec = static_cast< vector < long long>* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
#ifndef USE_NUMPY
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyLong_FromLongLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_LONGLONG);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(long long));
#endif
        return ret;
    }
    case 'K':   // vector<unsigned long long> - this is not used at present
    {
        vector< unsigned long long> * vec = static_cast< vector < unsigned long long>* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyLong_FromUnsignedLongLong(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_ULONGLONG);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(unsigned long long));
#endif
        return ret;
    }
    case 'F':   // vector<float>
    {
        vector< float > * vec = static_cast< vector < float >* >(obj);
        assert(vec != NULL);
#ifndef USE_NUMPY
        ret = PyTuple_New((Py_ssize_t)vec->size());
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (0 != PyTuple_SetItem(ret, ii, PyFloat_FromDouble(vec->at(ii))))
            {
                Py_DECREF(ret);
                return NULL;
            }
        }
#else
        npy_intp size = (npy_intp)(vec->size());
        ret = PyArray_SimpleNew(1, &size, NPY_FLOAT);
        assert(ret != NULL);
        char * ptr = PyArray_BYTES((PyArrayObject*)ret);
        memcpy(ptr, &(*vec)[0], size * sizeof(float));
#endif
        return ret;
    }
    case 's':   // vector<string>
    {
        vector< string > * vec = static_cast< vector < string >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            string v = vec->at(ii);
            if (convert_and_set_tuple_entry(ret, ii, (void*)&v, typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'N':   // vector< vector <unsigned int > >
    {
        vector< vector< unsigned int > > * vec = static_cast< vector < vector< unsigned int > >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'v':   // vector< vector < int > >
    {
        vector< vector< int > > * vec = static_cast< vector < vector< int > >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    case 'D':   // vector< vector <double > >
    {
        vector< vector< double > > * vec = static_cast< vector < vector< double > >* >(obj);
        assert(vec != NULL);
        ret = PyTuple_New((Py_ssize_t)vec->size());
        assert(ret != NULL);
        for (unsigned int ii = 0; ii < vec->size(); ++ii)
        {
            if (convert_and_set_tuple_entry(ret, ii, (void*)&vec->at(ii), typecode) == NULL)
            {
                return NULL;
            }
        }
        break;
    }
    default:
        PyErr_SetString(PyExc_TypeError, "unhandled type");
        return NULL;
    }
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

struct module_state _state

static

Definition at line 66 of file moosemodule.h.

unsigned char bytes[4]

Definition at line 41 of file moosemodule.h.

const { ... } o32_host_order

uint32_t value

Definition at line 42 of file moosemodule.h.

Referenced by ReadCell::addCaConc(), ReadCell::addCanonicalChannel(), HSolve::addInject(), ReadCell::buildChannels(), get_simple_lookupfield(), get_vec_lookupfield(), Func::getDerivative(), Function::getDerivative(), Func::getValue(), Function::getValue(), Func::initCinfo(), Function::initCinfo(), PulseGen::input(), isNaN(), moose::mapToString(), moose_ElementField_getSlice(), moose_ElementField_setattro(), moose_getField(), moose_getFieldDict(), moose_Id_fillSlice(), moose_Id_setattro(), moose_Id_setField(), moose_Id_subscript(), moose_ObjId_getattro(), moose_ObjId_getSlice(), moose_ObjId_setattro(), moose_ObjId_setField(), moose_ObjId_setLookupField(), SparseMatrix< unsigned int >::pairFill(), PyRun::process(), PyRun::PyRun(), PySequenceToVector(), PyRun::run(), SparseMatrix< unsigned int >::set(), IzhikevichNrn::setA(), MarkovGslSolver::setAbsoluteAccuracy(), IzhikevichNrn::setAccommodating(), IzhikevichNrn::setAlpha(), IzhikevichNrn::setB(), IzhikevichNrn::setBeta(), IzhikevichNrn::setC(), Nernst::setCin(), HSolve::setCm(), moose::VClamp::setCommand(), SteadyState::setConvergenceCriterion(), Nernst::setCout(), IzhikevichNrn::setD(), moose::CompartmentBase::setDiameter(), Interpol2D::setDx(), Interpol2D::setDy(), HSolve::setEk(), HSolve::setEm(), moose::VClamp::setGain(), IzhikevichNrn::setGamma(), HSolve::setGk(), HSolve::setHHChannelGbar(), HSolve::setHHmodulation(), IzhikevichNrn::setInitU(), HSolve::setInitVm(), IzhikevichNrn::setInitVm(), IzhikevichNrn::setInject(), HSolve::setInject(), Adaptor::setInputOffset(), MarkovGslSolver::setInternalDt(), MMPump::setKd(), moose::CompartmentBase::setLength(), setLookupField(), SteadyState::setMaxIter(), Cell::setMethod(), SynChan::setNormalizeWeights(), Adaptor::setOutputOffset(), Dsolve::setPath(), HSolve::setRa(), MarkovGslSolver::setRelativeAccuracy(), HSolve::setRm(), IzhikevichNrn::setRmByTau(), Nernst::setScale(), Adaptor::setScale(), Cell::setSolverClock(), Cell::setSolverName(), SteadyState::setStoich(), Interpol2D::setSy(), HHGate2D::setTableA(), HHGate2D::setTableB(), Interpol2D::setTableVector(), moose::VClamp::setTau(), moose::VClamp::setTd(), Nernst::setTemperature(), moose::VClamp::setTi(), IzhikevichNrn::setU0(), HHChannelBase::setUseConcentration(), Nernst::setValence(), Func::setVar(), moose::VClamp::setVin(), HSolve::setVm(), IzhikevichNrn::setVm(), MMPump::setVmax(), IzhikevichNrn::setVmax(), moose::CompartmentBase::setX(), HSolve::setX(), moose::CompartmentBase::setX0(), Interpol2D::setXmax(), Interpol::setXmax(), Interpol2D::setXmin(), Interpol::setXmin(), moose::CompartmentBase::setY(), HSolve::setY(), moose::CompartmentBase::setY0(), Interpol2D::setYmax(), Interpol2D::setYmin(), moose::CompartmentBase::setZ(), HSolve::setZ(), moose::CompartmentBase::setZ0(), to_cpp(), PyRun::trigger(), HSolvePassive::updateMatrix(), HSolveActive::updateMatrix(), DifBuffer::vSetActivation(), DifBuffer::vSetBBound(), DifBuffer::vSetBFree(), DifBuffer::vSetBTot(), DifBuffer::vSetD(), DifBuffer::vSetKb(), DifBuffer::vSetKf(), and HHChannel::vSetUseConcentration().