
/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaElmore
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaElmore_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaElmore_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaElmoreObject* self = (PyoaStringAppDef_oaElmoreObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaElmore)
    {
        PyParamoaStringAppDef_oaElmore p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaElmore_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaElmore, Choices are:\n"
        "    (oaStringAppDef_oaElmore)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaElmore_tp_dealloc(PyoaStringAppDef_oaElmoreObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaElmore_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaElmore value;
    int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[45];
    sprintf(buffer,"<oaStringAppDef_oaElmore::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaElmore_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaElmore v1;
    PyParamoaStringAppDef_oaElmore v2;
    int convert_status1=PyoaStringAppDef_oaElmore_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaElmore_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaElmore_Convert(PyObject* ob,PyParamoaStringAppDef_oaElmore* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaElmore_Check(ob)) {
        result->SetData( (oaStringAppDef_oaElmore**) ((PyoaStringAppDef_oaElmoreObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaElmore Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(oaStringAppDef_oaElmore** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaElmore* data=*value;
        PyObject* bself = PyoaStringAppDef_oaElmore_Type.tp_alloc(&PyoaStringAppDef_oaElmore_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaElmoreObject* self = (PyoaStringAppDef_oaElmoreObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(oaStringAppDef_oaElmore* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaElmore_Type.tp_alloc(&PyoaStringAppDef_oaElmore_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaElmoreObject* self = (PyoaStringAppDef_oaElmoreObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_get_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: get\n"
"  Paramegers: (oaElmore,oaString)\n"
"    Calls: void get(const oaElmore* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaElmore,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaElmore_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaElmore data;
    int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaElmoreObject* self=(PyoaStringAppDef_oaElmoreObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaElmore p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaElmore_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_getDefault_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaElmore_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaElmore data;
    int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaElmoreObject* self=(PyoaStringAppDef_oaElmoreObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_set_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: set\n"
"  Paramegers: (oaElmore,oaString)\n"
"    Calls: void set(oaElmore* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaElmore,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaElmore_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaElmore data;
    int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaElmoreObject* self=(PyoaStringAppDef_oaElmoreObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaElmore p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaElmore_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_isNull_doc[] =
"Class: oaStringAppDef_oaElmore, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaElmore_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaElmore data;
    int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaElmore_assign_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaElmore_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaElmore data;
  int convert_status=PyoaStringAppDef_oaElmore_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaElmore p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaElmore_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaElmore_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaElmore_get,METH_VARARGS,oaStringAppDef_oaElmore_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaElmore_getDefault,METH_VARARGS,oaStringAppDef_oaElmore_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaElmore_set,METH_VARARGS,oaStringAppDef_oaElmore_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaElmore_tp_isNull,METH_VARARGS,oaStringAppDef_oaElmore_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaElmore_tp_assign,METH_VARARGS,oaStringAppDef_oaElmore_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_doc[] = 
"Class: oaStringAppDef_oaElmore\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaElmore)\n"
"    Calls: (const oaStringAppDef_oaElmore&)\n"
"    Signature: oaStringAppDef_oaElmore||cref-oaStringAppDef_oaElmore,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaElmore_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaElmore",
    sizeof(PyoaStringAppDef_oaElmoreObject),
    0,
    (destructor)oaStringAppDef_oaElmore_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaElmore_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaElmore_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaElmore_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaElmore_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaElmore_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_static_find_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaElmore* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaElmore|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaElmore* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaElmore|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaElmore_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::find(p1.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaElmore, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaElmore_static_get_doc[] = 
"Class: oaStringAppDef_oaElmore, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaElmore* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaElmore|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaElmore_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaElmorep result= (oaStringAppDef_oaElmore::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaElmore_FromoaStringAppDef_oaElmore(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaElmore, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaElmore_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaElmore_static_find,METH_VARARGS,oaStringAppDef_oaElmore_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaElmore_static_get,METH_VARARGS,oaStringAppDef_oaElmore_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaElmore_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaElmore_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaElmore\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaElmore",
           (PyObject*)(&PyoaStringAppDef_oaElmore_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaElmore\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaElmore_Type.tp_dict;
    for(method=oaStringAppDef_oaElmore_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaFigGroup
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFigGroup_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaFigGroup_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaFigGroupObject* self = (PyoaStringAppDef_oaFigGroupObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaFigGroup)
    {
        PyParamoaStringAppDef_oaFigGroup p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaFigGroup_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaFigGroup, Choices are:\n"
        "    (oaStringAppDef_oaFigGroup)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaFigGroup_tp_dealloc(PyoaStringAppDef_oaFigGroupObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFigGroup_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaFigGroup value;
    int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[47];
    sprintf(buffer,"<oaStringAppDef_oaFigGroup::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaFigGroup_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaFigGroup v1;
    PyParamoaStringAppDef_oaFigGroup v2;
    int convert_status1=PyoaStringAppDef_oaFigGroup_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaFigGroup_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaFigGroup_Convert(PyObject* ob,PyParamoaStringAppDef_oaFigGroup* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaFigGroup_Check(ob)) {
        result->SetData( (oaStringAppDef_oaFigGroup**) ((PyoaStringAppDef_oaFigGroupObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaFigGroup Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(oaStringAppDef_oaFigGroup** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaFigGroup* data=*value;
        PyObject* bself = PyoaStringAppDef_oaFigGroup_Type.tp_alloc(&PyoaStringAppDef_oaFigGroup_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaFigGroupObject* self = (PyoaStringAppDef_oaFigGroupObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(oaStringAppDef_oaFigGroup* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaFigGroup_Type.tp_alloc(&PyoaStringAppDef_oaFigGroup_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaFigGroupObject* self = (PyoaStringAppDef_oaFigGroupObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_get_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: get\n"
"  Paramegers: (oaFigGroup,oaString)\n"
"    Calls: void get(const oaFigGroup* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaFigGroup,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroup data;
    int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupObject* self=(PyoaStringAppDef_oaFigGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFigGroup p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFigGroup_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_getDefault_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroup data;
    int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupObject* self=(PyoaStringAppDef_oaFigGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_set_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: set\n"
"  Paramegers: (oaFigGroup,oaString)\n"
"    Calls: void set(oaFigGroup* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaFigGroup,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroup data;
    int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupObject* self=(PyoaStringAppDef_oaFigGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFigGroup p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFigGroup_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_isNull_doc[] =
"Class: oaStringAppDef_oaFigGroup, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaFigGroup data;
    int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaFigGroup_assign_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaFigGroup data;
  int convert_status=PyoaStringAppDef_oaFigGroup_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaFigGroup p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaFigGroup_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaFigGroup_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaFigGroup_get,METH_VARARGS,oaStringAppDef_oaFigGroup_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaFigGroup_getDefault,METH_VARARGS,oaStringAppDef_oaFigGroup_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaFigGroup_set,METH_VARARGS,oaStringAppDef_oaFigGroup_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaFigGroup_tp_isNull,METH_VARARGS,oaStringAppDef_oaFigGroup_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaFigGroup_tp_assign,METH_VARARGS,oaStringAppDef_oaFigGroup_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_doc[] = 
"Class: oaStringAppDef_oaFigGroup\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaFigGroup)\n"
"    Calls: (const oaStringAppDef_oaFigGroup&)\n"
"    Signature: oaStringAppDef_oaFigGroup||cref-oaStringAppDef_oaFigGroup,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaFigGroup_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaFigGroup",
    sizeof(PyoaStringAppDef_oaFigGroupObject),
    0,
    (destructor)oaStringAppDef_oaFigGroup_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaFigGroup_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaFigGroup_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaFigGroup_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaFigGroup_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaFigGroup_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_static_find_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFigGroup* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaFigGroup|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFigGroup* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::find(p1.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFigGroup, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroup_static_get_doc[] = 
"Class: oaStringAppDef_oaFigGroup, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFigGroup* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaFigGroup_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupp result= (oaStringAppDef_oaFigGroup::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaFigGroup_FromoaStringAppDef_oaFigGroup(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFigGroup, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaFigGroup_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaFigGroup_static_find,METH_VARARGS,oaStringAppDef_oaFigGroup_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaFigGroup_static_get,METH_VARARGS,oaStringAppDef_oaFigGroup_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaFigGroup_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaFigGroup_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaFigGroup\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaFigGroup",
           (PyObject*)(&PyoaStringAppDef_oaFigGroup_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaFigGroup\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaFigGroup_Type.tp_dict;
    for(method=oaStringAppDef_oaFigGroup_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaFigGroupMem
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFigGroupMem_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaFigGroupMem_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaFigGroupMemObject* self = (PyoaStringAppDef_oaFigGroupMemObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaFigGroupMem)
    {
        PyParamoaStringAppDef_oaFigGroupMem p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaFigGroupMem_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaFigGroupMem, Choices are:\n"
        "    (oaStringAppDef_oaFigGroupMem)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaFigGroupMem_tp_dealloc(PyoaStringAppDef_oaFigGroupMemObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFigGroupMem_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaFigGroupMem value;
    int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaFigGroupMem::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaFigGroupMem_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaFigGroupMem v1;
    PyParamoaStringAppDef_oaFigGroupMem v2;
    int convert_status1=PyoaStringAppDef_oaFigGroupMem_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaFigGroupMem_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaFigGroupMem_Convert(PyObject* ob,PyParamoaStringAppDef_oaFigGroupMem* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaFigGroupMem_Check(ob)) {
        result->SetData( (oaStringAppDef_oaFigGroupMem**) ((PyoaStringAppDef_oaFigGroupMemObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaFigGroupMem Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(oaStringAppDef_oaFigGroupMem** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaFigGroupMem* data=*value;
        PyObject* bself = PyoaStringAppDef_oaFigGroupMem_Type.tp_alloc(&PyoaStringAppDef_oaFigGroupMem_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaFigGroupMemObject* self = (PyoaStringAppDef_oaFigGroupMemObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(oaStringAppDef_oaFigGroupMem* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaFigGroupMem_Type.tp_alloc(&PyoaStringAppDef_oaFigGroupMem_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaFigGroupMemObject* self = (PyoaStringAppDef_oaFigGroupMemObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_get_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: get\n"
"  Paramegers: (oaFigGroupMem,oaString)\n"
"    Calls: void get(const oaFigGroupMem* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaFigGroupMem,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroupMem data;
    int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupMemObject* self=(PyoaStringAppDef_oaFigGroupMemObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFigGroupMem p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFigGroupMem_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_getDefault_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroupMem data;
    int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupMemObject* self=(PyoaStringAppDef_oaFigGroupMemObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_set_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: set\n"
"  Paramegers: (oaFigGroupMem,oaString)\n"
"    Calls: void set(oaFigGroupMem* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaFigGroupMem,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFigGroupMem data;
    int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFigGroupMemObject* self=(PyoaStringAppDef_oaFigGroupMemObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFigGroupMem p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFigGroupMem_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_isNull_doc[] =
"Class: oaStringAppDef_oaFigGroupMem, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaFigGroupMem data;
    int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaFigGroupMem_assign_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaFigGroupMem data;
  int convert_status=PyoaStringAppDef_oaFigGroupMem_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaFigGroupMem p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaFigGroupMem_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaFigGroupMem_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaFigGroupMem_get,METH_VARARGS,oaStringAppDef_oaFigGroupMem_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaFigGroupMem_getDefault,METH_VARARGS,oaStringAppDef_oaFigGroupMem_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaFigGroupMem_set,METH_VARARGS,oaStringAppDef_oaFigGroupMem_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaFigGroupMem_tp_isNull,METH_VARARGS,oaStringAppDef_oaFigGroupMem_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaFigGroupMem_tp_assign,METH_VARARGS,oaStringAppDef_oaFigGroupMem_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaFigGroupMem)\n"
"    Calls: (const oaStringAppDef_oaFigGroupMem&)\n"
"    Signature: oaStringAppDef_oaFigGroupMem||cref-oaStringAppDef_oaFigGroupMem,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaFigGroupMem_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaFigGroupMem",
    sizeof(PyoaStringAppDef_oaFigGroupMemObject),
    0,
    (destructor)oaStringAppDef_oaFigGroupMem_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaFigGroupMem_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaFigGroupMem_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaFigGroupMem_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaFigGroupMem_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaFigGroupMem_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_static_find_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::find(p1.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFigGroupMem, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFigGroupMem_static_get_doc[] = 
"Class: oaStringAppDef_oaFigGroupMem, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFigGroupMem* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFigGroupMem|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaFigGroupMem_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFigGroupMemp result= (oaStringAppDef_oaFigGroupMem::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaFigGroupMem_FromoaStringAppDef_oaFigGroupMem(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFigGroupMem, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaFigGroupMem_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaFigGroupMem_static_find,METH_VARARGS,oaStringAppDef_oaFigGroupMem_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaFigGroupMem_static_get,METH_VARARGS,oaStringAppDef_oaFigGroupMem_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaFigGroupMem_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaFigGroupMem_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaFigGroupMem\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaFigGroupMem",
           (PyObject*)(&PyoaStringAppDef_oaFigGroupMem_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaFigGroupMem\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaFigGroupMem_Type.tp_dict;
    for(method=oaStringAppDef_oaFigGroupMem_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaFrame
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFrame_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaFrame_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaFrameObject* self = (PyoaStringAppDef_oaFrameObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaFrame)
    {
        PyParamoaStringAppDef_oaFrame p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaFrame_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaFrame, Choices are:\n"
        "    (oaStringAppDef_oaFrame)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaFrame_tp_dealloc(PyoaStringAppDef_oaFrameObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFrame_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaFrame value;
    int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[44];
    sprintf(buffer,"<oaStringAppDef_oaFrame::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaFrame_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaFrame v1;
    PyParamoaStringAppDef_oaFrame v2;
    int convert_status1=PyoaStringAppDef_oaFrame_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaFrame_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaFrame_Convert(PyObject* ob,PyParamoaStringAppDef_oaFrame* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaFrame_Check(ob)) {
        result->SetData( (oaStringAppDef_oaFrame**) ((PyoaStringAppDef_oaFrameObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaFrame Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(oaStringAppDef_oaFrame** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaFrame* data=*value;
        PyObject* bself = PyoaStringAppDef_oaFrame_Type.tp_alloc(&PyoaStringAppDef_oaFrame_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaFrameObject* self = (PyoaStringAppDef_oaFrameObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(oaStringAppDef_oaFrame* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaFrame_Type.tp_alloc(&PyoaStringAppDef_oaFrame_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaFrameObject* self = (PyoaStringAppDef_oaFrameObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_get_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: get\n"
"  Paramegers: (oaFrame,oaString)\n"
"    Calls: void get(const oaFrame* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaFrame,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFrame_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrame data;
    int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameObject* self=(PyoaStringAppDef_oaFrameObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFrame p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFrame_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_getDefault_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaFrame_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrame data;
    int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameObject* self=(PyoaStringAppDef_oaFrameObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_set_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: set\n"
"  Paramegers: (oaFrame,oaString)\n"
"    Calls: void set(oaFrame* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaFrame,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFrame_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrame data;
    int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameObject* self=(PyoaStringAppDef_oaFrameObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFrame p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFrame_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_isNull_doc[] =
"Class: oaStringAppDef_oaFrame, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaFrame_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaFrame data;
    int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaFrame_assign_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaFrame_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaFrame data;
  int convert_status=PyoaStringAppDef_oaFrame_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaFrame p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaFrame_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaFrame_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaFrame_get,METH_VARARGS,oaStringAppDef_oaFrame_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaFrame_getDefault,METH_VARARGS,oaStringAppDef_oaFrame_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaFrame_set,METH_VARARGS,oaStringAppDef_oaFrame_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaFrame_tp_isNull,METH_VARARGS,oaStringAppDef_oaFrame_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaFrame_tp_assign,METH_VARARGS,oaStringAppDef_oaFrame_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_doc[] = 
"Class: oaStringAppDef_oaFrame\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaFrame)\n"
"    Calls: (const oaStringAppDef_oaFrame&)\n"
"    Signature: oaStringAppDef_oaFrame||cref-oaStringAppDef_oaFrame,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaFrame_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaFrame",
    sizeof(PyoaStringAppDef_oaFrameObject),
    0,
    (destructor)oaStringAppDef_oaFrame_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaFrame_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaFrame_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaFrame_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaFrame_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaFrame_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_static_find_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFrame* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaFrame|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFrame* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaFrame|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaFrame_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::find(p1.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFrame, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrame_static_get_doc[] = 
"Class: oaStringAppDef_oaFrame, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFrame* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrame|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaFrame_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFramep result= (oaStringAppDef_oaFrame::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaFrame_FromoaStringAppDef_oaFrame(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFrame, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaFrame_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaFrame_static_find,METH_VARARGS,oaStringAppDef_oaFrame_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaFrame_static_get,METH_VARARGS,oaStringAppDef_oaFrame_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaFrame_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaFrame_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaFrame\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaFrame",
           (PyObject*)(&PyoaStringAppDef_oaFrame_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaFrame\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaFrame_Type.tp_dict;
    for(method=oaStringAppDef_oaFrame_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaFrameInst
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFrameInst_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaFrameInst_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaFrameInstObject* self = (PyoaStringAppDef_oaFrameInstObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaFrameInst)
    {
        PyParamoaStringAppDef_oaFrameInst p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaFrameInst_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaFrameInst, Choices are:\n"
        "    (oaStringAppDef_oaFrameInst)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaFrameInst_tp_dealloc(PyoaStringAppDef_oaFrameInstObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaFrameInst_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaFrameInst value;
    int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[48];
    sprintf(buffer,"<oaStringAppDef_oaFrameInst::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaFrameInst_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaFrameInst v1;
    PyParamoaStringAppDef_oaFrameInst v2;
    int convert_status1=PyoaStringAppDef_oaFrameInst_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaFrameInst_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaFrameInst_Convert(PyObject* ob,PyParamoaStringAppDef_oaFrameInst* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaFrameInst_Check(ob)) {
        result->SetData( (oaStringAppDef_oaFrameInst**) ((PyoaStringAppDef_oaFrameInstObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaFrameInst Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(oaStringAppDef_oaFrameInst** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaFrameInst* data=*value;
        PyObject* bself = PyoaStringAppDef_oaFrameInst_Type.tp_alloc(&PyoaStringAppDef_oaFrameInst_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaFrameInstObject* self = (PyoaStringAppDef_oaFrameInstObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(oaStringAppDef_oaFrameInst* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaFrameInst_Type.tp_alloc(&PyoaStringAppDef_oaFrameInst_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaFrameInstObject* self = (PyoaStringAppDef_oaFrameInstObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_get_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: get\n"
"  Paramegers: (oaFrameInst,oaString)\n"
"    Calls: void get(const oaFrameInst* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaFrameInst,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrameInst data;
    int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameInstObject* self=(PyoaStringAppDef_oaFrameInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFrameInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFrameInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_getDefault_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrameInst data;
    int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameInstObject* self=(PyoaStringAppDef_oaFrameInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_set_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: set\n"
"  Paramegers: (oaFrameInst,oaString)\n"
"    Calls: void set(oaFrameInst* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaFrameInst,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaFrameInst data;
    int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaFrameInstObject* self=(PyoaStringAppDef_oaFrameInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaFrameInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaFrameInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_isNull_doc[] =
"Class: oaStringAppDef_oaFrameInst, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaFrameInst data;
    int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaFrameInst_assign_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaFrameInst data;
  int convert_status=PyoaStringAppDef_oaFrameInst_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaFrameInst p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaFrameInst_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaFrameInst_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaFrameInst_get,METH_VARARGS,oaStringAppDef_oaFrameInst_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaFrameInst_getDefault,METH_VARARGS,oaStringAppDef_oaFrameInst_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaFrameInst_set,METH_VARARGS,oaStringAppDef_oaFrameInst_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaFrameInst_tp_isNull,METH_VARARGS,oaStringAppDef_oaFrameInst_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaFrameInst_tp_assign,METH_VARARGS,oaStringAppDef_oaFrameInst_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_doc[] = 
"Class: oaStringAppDef_oaFrameInst\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaFrameInst)\n"
"    Calls: (const oaStringAppDef_oaFrameInst&)\n"
"    Signature: oaStringAppDef_oaFrameInst||cref-oaStringAppDef_oaFrameInst,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaFrameInst_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaFrameInst",
    sizeof(PyoaStringAppDef_oaFrameInstObject),
    0,
    (destructor)oaStringAppDef_oaFrameInst_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaFrameInst_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaFrameInst_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaFrameInst_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaFrameInst_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaFrameInst_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_static_find_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFrameInst* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaFrameInst|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFrameInst* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::find(p1.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFrameInst, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaFrameInst_static_get_doc[] = 
"Class: oaStringAppDef_oaFrameInst, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaFrameInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaFrameInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaFrameInst_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaFrameInstp result= (oaStringAppDef_oaFrameInst::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaFrameInst_FromoaStringAppDef_oaFrameInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaFrameInst, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaFrameInst_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaFrameInst_static_find,METH_VARARGS,oaStringAppDef_oaFrameInst_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaFrameInst_static_get,METH_VARARGS,oaStringAppDef_oaFrameInst_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaFrameInst_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaFrameInst_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaFrameInst\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaFrameInst",
           (PyObject*)(&PyoaStringAppDef_oaFrameInst_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaFrameInst\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaFrameInst_Type.tp_dict;
    for(method=oaStringAppDef_oaFrameInst_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaGCellPattern
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGCellPattern_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaGCellPattern_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaGCellPatternObject* self = (PyoaStringAppDef_oaGCellPatternObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaGCellPattern)
    {
        PyParamoaStringAppDef_oaGCellPattern p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaGCellPattern_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaGCellPattern, Choices are:\n"
        "    (oaStringAppDef_oaGCellPattern)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaGCellPattern_tp_dealloc(PyoaStringAppDef_oaGCellPatternObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGCellPattern_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaGCellPattern value;
    int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[51];
    sprintf(buffer,"<oaStringAppDef_oaGCellPattern::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaGCellPattern_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaGCellPattern v1;
    PyParamoaStringAppDef_oaGCellPattern v2;
    int convert_status1=PyoaStringAppDef_oaGCellPattern_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaGCellPattern_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaGCellPattern_Convert(PyObject* ob,PyParamoaStringAppDef_oaGCellPattern* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaGCellPattern_Check(ob)) {
        result->SetData( (oaStringAppDef_oaGCellPattern**) ((PyoaStringAppDef_oaGCellPatternObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaGCellPattern Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(oaStringAppDef_oaGCellPattern** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaGCellPattern* data=*value;
        PyObject* bself = PyoaStringAppDef_oaGCellPattern_Type.tp_alloc(&PyoaStringAppDef_oaGCellPattern_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaGCellPatternObject* self = (PyoaStringAppDef_oaGCellPatternObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(oaStringAppDef_oaGCellPattern* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaGCellPattern_Type.tp_alloc(&PyoaStringAppDef_oaGCellPattern_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaGCellPatternObject* self = (PyoaStringAppDef_oaGCellPatternObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_get_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: get\n"
"  Paramegers: (oaGCellPattern,oaString)\n"
"    Calls: void get(const oaGCellPattern* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaGCellPattern,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGCellPattern data;
    int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGCellPatternObject* self=(PyoaStringAppDef_oaGCellPatternObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGCellPattern p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGCellPattern_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_getDefault_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGCellPattern data;
    int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGCellPatternObject* self=(PyoaStringAppDef_oaGCellPatternObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_set_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: set\n"
"  Paramegers: (oaGCellPattern,oaString)\n"
"    Calls: void set(oaGCellPattern* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaGCellPattern,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGCellPattern data;
    int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGCellPatternObject* self=(PyoaStringAppDef_oaGCellPatternObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGCellPattern p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGCellPattern_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_isNull_doc[] =
"Class: oaStringAppDef_oaGCellPattern, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaGCellPattern data;
    int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaGCellPattern_assign_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaGCellPattern data;
  int convert_status=PyoaStringAppDef_oaGCellPattern_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaGCellPattern p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaGCellPattern_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaGCellPattern_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaGCellPattern_get,METH_VARARGS,oaStringAppDef_oaGCellPattern_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaGCellPattern_getDefault,METH_VARARGS,oaStringAppDef_oaGCellPattern_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaGCellPattern_set,METH_VARARGS,oaStringAppDef_oaGCellPattern_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaGCellPattern_tp_isNull,METH_VARARGS,oaStringAppDef_oaGCellPattern_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaGCellPattern_tp_assign,METH_VARARGS,oaStringAppDef_oaGCellPattern_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_doc[] = 
"Class: oaStringAppDef_oaGCellPattern\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaGCellPattern)\n"
"    Calls: (const oaStringAppDef_oaGCellPattern&)\n"
"    Signature: oaStringAppDef_oaGCellPattern||cref-oaStringAppDef_oaGCellPattern,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaGCellPattern_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaGCellPattern",
    sizeof(PyoaStringAppDef_oaGCellPatternObject),
    0,
    (destructor)oaStringAppDef_oaGCellPattern_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaGCellPattern_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaGCellPattern_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaGCellPattern_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaGCellPattern_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaGCellPattern_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_static_find_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGCellPattern* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGCellPattern* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::find(p1.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGCellPattern, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGCellPattern_static_get_doc[] = 
"Class: oaStringAppDef_oaGCellPattern, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGCellPattern* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGCellPattern|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaGCellPattern_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGCellPatternp result= (oaStringAppDef_oaGCellPattern::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaGCellPattern_FromoaStringAppDef_oaGCellPattern(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGCellPattern, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaGCellPattern_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaGCellPattern_static_find,METH_VARARGS,oaStringAppDef_oaGCellPattern_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaGCellPattern_static_get,METH_VARARGS,oaStringAppDef_oaGCellPattern_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaGCellPattern_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaGCellPattern_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaGCellPattern\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaGCellPattern",
           (PyObject*)(&PyoaStringAppDef_oaGCellPattern_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaGCellPattern\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaGCellPattern_Type.tp_dict;
    for(method=oaStringAppDef_oaGCellPattern_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaGroup
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGroup_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaGroup_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaGroupObject* self = (PyoaStringAppDef_oaGroupObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaGroup)
    {
        PyParamoaStringAppDef_oaGroup p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaGroup_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaGroup, Choices are:\n"
        "    (oaStringAppDef_oaGroup)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaGroup_tp_dealloc(PyoaStringAppDef_oaGroupObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGroup_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaGroup value;
    int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[44];
    sprintf(buffer,"<oaStringAppDef_oaGroup::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaGroup_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaGroup v1;
    PyParamoaStringAppDef_oaGroup v2;
    int convert_status1=PyoaStringAppDef_oaGroup_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaGroup_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaGroup_Convert(PyObject* ob,PyParamoaStringAppDef_oaGroup* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaGroup_Check(ob)) {
        result->SetData( (oaStringAppDef_oaGroup**) ((PyoaStringAppDef_oaGroupObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaGroup Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(oaStringAppDef_oaGroup** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaGroup* data=*value;
        PyObject* bself = PyoaStringAppDef_oaGroup_Type.tp_alloc(&PyoaStringAppDef_oaGroup_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaGroupObject* self = (PyoaStringAppDef_oaGroupObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(oaStringAppDef_oaGroup* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaGroup_Type.tp_alloc(&PyoaStringAppDef_oaGroup_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaGroupObject* self = (PyoaStringAppDef_oaGroupObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_get_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: get\n"
"  Paramegers: (oaGroup,oaString)\n"
"    Calls: void get(const oaGroup* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaGroup,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGroup_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroup data;
    int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupObject* self=(PyoaStringAppDef_oaGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGroup p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGroup_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_getDefault_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaGroup_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroup data;
    int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupObject* self=(PyoaStringAppDef_oaGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_set_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: set\n"
"  Paramegers: (oaGroup,oaString)\n"
"    Calls: void set(oaGroup* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaGroup,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGroup_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroup data;
    int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupObject* self=(PyoaStringAppDef_oaGroupObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGroup p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGroup_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_isNull_doc[] =
"Class: oaStringAppDef_oaGroup, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaGroup_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaGroup data;
    int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaGroup_assign_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaGroup_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaGroup data;
  int convert_status=PyoaStringAppDef_oaGroup_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaGroup p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaGroup_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaGroup_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaGroup_get,METH_VARARGS,oaStringAppDef_oaGroup_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaGroup_getDefault,METH_VARARGS,oaStringAppDef_oaGroup_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaGroup_set,METH_VARARGS,oaStringAppDef_oaGroup_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaGroup_tp_isNull,METH_VARARGS,oaStringAppDef_oaGroup_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaGroup_tp_assign,METH_VARARGS,oaStringAppDef_oaGroup_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_doc[] = 
"Class: oaStringAppDef_oaGroup\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaGroup)\n"
"    Calls: (const oaStringAppDef_oaGroup&)\n"
"    Signature: oaStringAppDef_oaGroup||cref-oaStringAppDef_oaGroup,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaGroup_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaGroup",
    sizeof(PyoaStringAppDef_oaGroupObject),
    0,
    (destructor)oaStringAppDef_oaGroup_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaGroup_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaGroup_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaGroup_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaGroup_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaGroup_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_static_find_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGroup* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaGroup|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGroup* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaGroup|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaGroup_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::find(p1.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGroup, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroup_static_get_doc[] = 
"Class: oaStringAppDef_oaGroup, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGroup* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroup|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaGroup_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupp result= (oaStringAppDef_oaGroup::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaGroup_FromoaStringAppDef_oaGroup(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGroup, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaGroup_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaGroup_static_find,METH_VARARGS,oaStringAppDef_oaGroup_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaGroup_static_get,METH_VARARGS,oaStringAppDef_oaGroup_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaGroup_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaGroup_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaGroup\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaGroup",
           (PyObject*)(&PyoaStringAppDef_oaGroup_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaGroup\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaGroup_Type.tp_dict;
    for(method=oaStringAppDef_oaGroup_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaGroupMember
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGroupMember_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaGroupMember_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaGroupMemberObject* self = (PyoaStringAppDef_oaGroupMemberObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaGroupMember)
    {
        PyParamoaStringAppDef_oaGroupMember p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaGroupMember_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaGroupMember, Choices are:\n"
        "    (oaStringAppDef_oaGroupMember)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaGroupMember_tp_dealloc(PyoaStringAppDef_oaGroupMemberObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGroupMember_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaGroupMember value;
    int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaGroupMember::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaGroupMember_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaGroupMember v1;
    PyParamoaStringAppDef_oaGroupMember v2;
    int convert_status1=PyoaStringAppDef_oaGroupMember_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaGroupMember_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaGroupMember_Convert(PyObject* ob,PyParamoaStringAppDef_oaGroupMember* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaGroupMember_Check(ob)) {
        result->SetData( (oaStringAppDef_oaGroupMember**) ((PyoaStringAppDef_oaGroupMemberObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaGroupMember Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(oaStringAppDef_oaGroupMember** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaGroupMember* data=*value;
        PyObject* bself = PyoaStringAppDef_oaGroupMember_Type.tp_alloc(&PyoaStringAppDef_oaGroupMember_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaGroupMemberObject* self = (PyoaStringAppDef_oaGroupMemberObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(oaStringAppDef_oaGroupMember* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaGroupMember_Type.tp_alloc(&PyoaStringAppDef_oaGroupMember_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaGroupMemberObject* self = (PyoaStringAppDef_oaGroupMemberObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_get_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: get\n"
"  Paramegers: (oaGroupMember,oaString)\n"
"    Calls: void get(const oaGroupMember* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaGroupMember,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroupMember data;
    int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupMemberObject* self=(PyoaStringAppDef_oaGroupMemberObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGroupMember p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGroupMember_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_getDefault_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroupMember data;
    int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupMemberObject* self=(PyoaStringAppDef_oaGroupMemberObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_set_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: set\n"
"  Paramegers: (oaGroupMember,oaString)\n"
"    Calls: void set(oaGroupMember* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaGroupMember,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGroupMember data;
    int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGroupMemberObject* self=(PyoaStringAppDef_oaGroupMemberObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGroupMember p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGroupMember_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_isNull_doc[] =
"Class: oaStringAppDef_oaGroupMember, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaGroupMember data;
    int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaGroupMember_assign_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaGroupMember data;
  int convert_status=PyoaStringAppDef_oaGroupMember_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaGroupMember p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaGroupMember_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaGroupMember_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaGroupMember_get,METH_VARARGS,oaStringAppDef_oaGroupMember_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaGroupMember_getDefault,METH_VARARGS,oaStringAppDef_oaGroupMember_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaGroupMember_set,METH_VARARGS,oaStringAppDef_oaGroupMember_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaGroupMember_tp_isNull,METH_VARARGS,oaStringAppDef_oaGroupMember_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaGroupMember_tp_assign,METH_VARARGS,oaStringAppDef_oaGroupMember_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_doc[] = 
"Class: oaStringAppDef_oaGroupMember\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaGroupMember)\n"
"    Calls: (const oaStringAppDef_oaGroupMember&)\n"
"    Signature: oaStringAppDef_oaGroupMember||cref-oaStringAppDef_oaGroupMember,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaGroupMember_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaGroupMember",
    sizeof(PyoaStringAppDef_oaGroupMemberObject),
    0,
    (destructor)oaStringAppDef_oaGroupMember_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaGroupMember_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaGroupMember_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaGroupMember_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaGroupMember_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaGroupMember_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_static_find_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGroupMember* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaGroupMember|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGroupMember* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::find(p1.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGroupMember, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGroupMember_static_get_doc[] = 
"Class: oaStringAppDef_oaGroupMember, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGroupMember* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGroupMember|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaGroupMember_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGroupMemberp result= (oaStringAppDef_oaGroupMember::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaGroupMember_FromoaStringAppDef_oaGroupMember(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGroupMember, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaGroupMember_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaGroupMember_static_find,METH_VARARGS,oaStringAppDef_oaGroupMember_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaGroupMember_static_get,METH_VARARGS,oaStringAppDef_oaGroupMember_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaGroupMember_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaGroupMember_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaGroupMember\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaGroupMember",
           (PyObject*)(&PyoaStringAppDef_oaGroupMember_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaGroupMember\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaGroupMember_Type.tp_dict;
    for(method=oaStringAppDef_oaGroupMember_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaGuide
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGuide_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaGuide_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaGuideObject* self = (PyoaStringAppDef_oaGuideObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaGuide)
    {
        PyParamoaStringAppDef_oaGuide p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaGuide_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaGuide, Choices are:\n"
        "    (oaStringAppDef_oaGuide)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaGuide_tp_dealloc(PyoaStringAppDef_oaGuideObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaGuide_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaGuide value;
    int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[44];
    sprintf(buffer,"<oaStringAppDef_oaGuide::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaGuide_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaGuide v1;
    PyParamoaStringAppDef_oaGuide v2;
    int convert_status1=PyoaStringAppDef_oaGuide_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaGuide_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaGuide_Convert(PyObject* ob,PyParamoaStringAppDef_oaGuide* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaGuide_Check(ob)) {
        result->SetData( (oaStringAppDef_oaGuide**) ((PyoaStringAppDef_oaGuideObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaGuide Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(oaStringAppDef_oaGuide** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaGuide* data=*value;
        PyObject* bself = PyoaStringAppDef_oaGuide_Type.tp_alloc(&PyoaStringAppDef_oaGuide_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaGuideObject* self = (PyoaStringAppDef_oaGuideObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(oaStringAppDef_oaGuide* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaGuide_Type.tp_alloc(&PyoaStringAppDef_oaGuide_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaGuideObject* self = (PyoaStringAppDef_oaGuideObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_get_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: get\n"
"  Paramegers: (oaGuide,oaString)\n"
"    Calls: void get(const oaGuide* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaGuide,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGuide_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGuide data;
    int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGuideObject* self=(PyoaStringAppDef_oaGuideObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGuide p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGuide_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_getDefault_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaGuide_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGuide data;
    int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGuideObject* self=(PyoaStringAppDef_oaGuideObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_set_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: set\n"
"  Paramegers: (oaGuide,oaString)\n"
"    Calls: void set(oaGuide* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaGuide,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaGuide_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaGuide data;
    int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaGuideObject* self=(PyoaStringAppDef_oaGuideObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaGuide p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaGuide_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_isNull_doc[] =
"Class: oaStringAppDef_oaGuide, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaGuide_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaGuide data;
    int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaGuide_assign_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaGuide_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaGuide data;
  int convert_status=PyoaStringAppDef_oaGuide_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaGuide p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaGuide_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaGuide_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaGuide_get,METH_VARARGS,oaStringAppDef_oaGuide_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaGuide_getDefault,METH_VARARGS,oaStringAppDef_oaGuide_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaGuide_set,METH_VARARGS,oaStringAppDef_oaGuide_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaGuide_tp_isNull,METH_VARARGS,oaStringAppDef_oaGuide_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaGuide_tp_assign,METH_VARARGS,oaStringAppDef_oaGuide_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_doc[] = 
"Class: oaStringAppDef_oaGuide\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaGuide)\n"
"    Calls: (const oaStringAppDef_oaGuide&)\n"
"    Signature: oaStringAppDef_oaGuide||cref-oaStringAppDef_oaGuide,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaGuide_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaGuide",
    sizeof(PyoaStringAppDef_oaGuideObject),
    0,
    (destructor)oaStringAppDef_oaGuide_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaGuide_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaGuide_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaGuide_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaGuide_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaGuide_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_static_find_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGuide* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaGuide|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGuide* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaGuide|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaGuide_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::find(p1.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGuide, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaGuide_static_get_doc[] = 
"Class: oaStringAppDef_oaGuide, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaGuide* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaGuide|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaGuide_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaGuidep result= (oaStringAppDef_oaGuide::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaGuide_FromoaStringAppDef_oaGuide(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaGuide, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaGuide_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaGuide_static_find,METH_VARARGS,oaStringAppDef_oaGuide_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaGuide_static_get,METH_VARARGS,oaStringAppDef_oaGuide_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaGuide_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaGuide_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaGuide\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaGuide",
           (PyObject*)(&PyoaStringAppDef_oaGuide_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaGuide\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaGuide_Type.tp_dict;
    for(method=oaStringAppDef_oaGuide_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaImage
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaImage_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaImage_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaImageObject* self = (PyoaStringAppDef_oaImageObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaImage)
    {
        PyParamoaStringAppDef_oaImage p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaImage_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaImage, Choices are:\n"
        "    (oaStringAppDef_oaImage)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaImage_tp_dealloc(PyoaStringAppDef_oaImageObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaImage_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaImage value;
    int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[44];
    sprintf(buffer,"<oaStringAppDef_oaImage::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaImage_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaImage v1;
    PyParamoaStringAppDef_oaImage v2;
    int convert_status1=PyoaStringAppDef_oaImage_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaImage_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaImage_Convert(PyObject* ob,PyParamoaStringAppDef_oaImage* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaImage_Check(ob)) {
        result->SetData( (oaStringAppDef_oaImage**) ((PyoaStringAppDef_oaImageObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaImage Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(oaStringAppDef_oaImage** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaImage* data=*value;
        PyObject* bself = PyoaStringAppDef_oaImage_Type.tp_alloc(&PyoaStringAppDef_oaImage_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaImageObject* self = (PyoaStringAppDef_oaImageObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(oaStringAppDef_oaImage* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaImage_Type.tp_alloc(&PyoaStringAppDef_oaImage_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaImageObject* self = (PyoaStringAppDef_oaImageObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_get_doc[] = 
"Class: oaStringAppDef_oaImage, Function: get\n"
"  Paramegers: (oaImage,oaString)\n"
"    Calls: void get(const oaImage* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaImage,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaImage_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaImage data;
    int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaImageObject* self=(PyoaStringAppDef_oaImageObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaImage p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaImage_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_getDefault_doc[] = 
"Class: oaStringAppDef_oaImage, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaImage_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaImage data;
    int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaImageObject* self=(PyoaStringAppDef_oaImageObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_set_doc[] = 
"Class: oaStringAppDef_oaImage, Function: set\n"
"  Paramegers: (oaImage,oaString)\n"
"    Calls: void set(oaImage* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaImage,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaImage_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaImage data;
    int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaImageObject* self=(PyoaStringAppDef_oaImageObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaImage p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaImage_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_isNull_doc[] =
"Class: oaStringAppDef_oaImage, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaImage_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaImage data;
    int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaImage_assign_doc[] = 
"Class: oaStringAppDef_oaImage, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaImage_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaImage data;
  int convert_status=PyoaStringAppDef_oaImage_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaImage p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaImage_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaImage_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaImage_get,METH_VARARGS,oaStringAppDef_oaImage_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaImage_getDefault,METH_VARARGS,oaStringAppDef_oaImage_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaImage_set,METH_VARARGS,oaStringAppDef_oaImage_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaImage_tp_isNull,METH_VARARGS,oaStringAppDef_oaImage_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaImage_tp_assign,METH_VARARGS,oaStringAppDef_oaImage_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_doc[] = 
"Class: oaStringAppDef_oaImage\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaImage)\n"
"    Calls: (const oaStringAppDef_oaImage&)\n"
"    Signature: oaStringAppDef_oaImage||cref-oaStringAppDef_oaImage,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaImage_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaImage",
    sizeof(PyoaStringAppDef_oaImageObject),
    0,
    (destructor)oaStringAppDef_oaImage_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaImage_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaImage_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaImage_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaImage_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaImage_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_static_find_doc[] = 
"Class: oaStringAppDef_oaImage, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaImage* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaImage|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaImage* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaImage|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaImage_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::find(p1.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaImage, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaImage_static_get_doc[] = 
"Class: oaStringAppDef_oaImage, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaImage* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaImage|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaImage_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaImagep result= (oaStringAppDef_oaImage::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaImage_FromoaStringAppDef_oaImage(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaImage, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaImage_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaImage_static_find,METH_VARARGS,oaStringAppDef_oaImage_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaImage_static_get,METH_VARARGS,oaStringAppDef_oaImage_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaImage_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaImage_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaImage\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaImage",
           (PyObject*)(&PyoaStringAppDef_oaImage_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaImage\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaImage_Type.tp_dict;
    for(method=oaStringAppDef_oaImage_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaInst
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInst_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaInst_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaInstObject* self = (PyoaStringAppDef_oaInstObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaInst)
    {
        PyParamoaStringAppDef_oaInst p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaInst_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaInst, Choices are:\n"
        "    (oaStringAppDef_oaInst)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaInst_tp_dealloc(PyoaStringAppDef_oaInstObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInst_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaInst value;
    int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[43];
    sprintf(buffer,"<oaStringAppDef_oaInst::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaInst_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaInst v1;
    PyParamoaStringAppDef_oaInst v2;
    int convert_status1=PyoaStringAppDef_oaInst_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaInst_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaInst_Convert(PyObject* ob,PyParamoaStringAppDef_oaInst* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaInst_Check(ob)) {
        result->SetData( (oaStringAppDef_oaInst**) ((PyoaStringAppDef_oaInstObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaInst Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(oaStringAppDef_oaInst** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaInst* data=*value;
        PyObject* bself = PyoaStringAppDef_oaInst_Type.tp_alloc(&PyoaStringAppDef_oaInst_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaInstObject* self = (PyoaStringAppDef_oaInstObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(oaStringAppDef_oaInst* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaInst_Type.tp_alloc(&PyoaStringAppDef_oaInst_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaInstObject* self = (PyoaStringAppDef_oaInstObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_get_doc[] = 
"Class: oaStringAppDef_oaInst, Function: get\n"
"  Paramegers: (oaInst,oaString)\n"
"    Calls: void get(const oaInst* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaInst,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInst_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInst data;
    int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstObject* self=(PyoaStringAppDef_oaInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_getDefault_doc[] = 
"Class: oaStringAppDef_oaInst, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaInst_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInst data;
    int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstObject* self=(PyoaStringAppDef_oaInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_set_doc[] = 
"Class: oaStringAppDef_oaInst, Function: set\n"
"  Paramegers: (oaInst,oaString)\n"
"    Calls: void set(oaInst* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaInst,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInst_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInst data;
    int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstObject* self=(PyoaStringAppDef_oaInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_isNull_doc[] =
"Class: oaStringAppDef_oaInst, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaInst_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaInst data;
    int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaInst_assign_doc[] = 
"Class: oaStringAppDef_oaInst, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaInst_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaInst data;
  int convert_status=PyoaStringAppDef_oaInst_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaInst p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaInst_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaInst_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaInst_get,METH_VARARGS,oaStringAppDef_oaInst_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaInst_getDefault,METH_VARARGS,oaStringAppDef_oaInst_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaInst_set,METH_VARARGS,oaStringAppDef_oaInst_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaInst_tp_isNull,METH_VARARGS,oaStringAppDef_oaInst_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaInst_tp_assign,METH_VARARGS,oaStringAppDef_oaInst_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_doc[] = 
"Class: oaStringAppDef_oaInst\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaInst)\n"
"    Calls: (const oaStringAppDef_oaInst&)\n"
"    Signature: oaStringAppDef_oaInst||cref-oaStringAppDef_oaInst,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaInst_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaInst",
    sizeof(PyoaStringAppDef_oaInstObject),
    0,
    (destructor)oaStringAppDef_oaInst_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaInst_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaInst_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaInst_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaInst_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaInst_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_static_find_doc[] = 
"Class: oaStringAppDef_oaInst, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInst* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaInst|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInst* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaInst|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaInst_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::find(p1.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInst, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInst_static_get_doc[] = 
"Class: oaStringAppDef_oaInst, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaInst_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstp result= (oaStringAppDef_oaInst::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaInst_FromoaStringAppDef_oaInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInst, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaInst_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaInst_static_find,METH_VARARGS,oaStringAppDef_oaInst_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaInst_static_get,METH_VARARGS,oaStringAppDef_oaInst_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaInst_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaInst_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaInst\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaInst",
           (PyObject*)(&PyoaStringAppDef_oaInst_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaInst\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaInst_Type.tp_dict;
    for(method=oaStringAppDef_oaInst_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaInstHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInstHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaInstHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaInstHeaderObject* self = (PyoaStringAppDef_oaInstHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaInstHeader)
    {
        PyParamoaStringAppDef_oaInstHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaInstHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaInstHeader, Choices are:\n"
        "    (oaStringAppDef_oaInstHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaInstHeader_tp_dealloc(PyoaStringAppDef_oaInstHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInstHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaInstHeader value;
    int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[49];
    sprintf(buffer,"<oaStringAppDef_oaInstHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaInstHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaInstHeader v1;
    PyParamoaStringAppDef_oaInstHeader v2;
    int convert_status1=PyoaStringAppDef_oaInstHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaInstHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaInstHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaInstHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaInstHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaInstHeader**) ((PyoaStringAppDef_oaInstHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaInstHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(oaStringAppDef_oaInstHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaInstHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaInstHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaInstHeaderObject* self = (PyoaStringAppDef_oaInstHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(oaStringAppDef_oaInstHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaInstHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaInstHeaderObject* self = (PyoaStringAppDef_oaInstHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_get_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: get\n"
"  Paramegers: (oaInstHeader,oaString)\n"
"    Calls: void get(const oaInstHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaInstHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstHeader data;
    int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstHeaderObject* self=(PyoaStringAppDef_oaInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstHeader data;
    int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstHeaderObject* self=(PyoaStringAppDef_oaInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_set_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: set\n"
"  Paramegers: (oaInstHeader,oaString)\n"
"    Calls: void set(oaInstHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaInstHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstHeader data;
    int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstHeaderObject* self=(PyoaStringAppDef_oaInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_isNull_doc[] =
"Class: oaStringAppDef_oaInstHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaInstHeader data;
    int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaInstHeader_assign_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaInstHeader data;
  int convert_status=PyoaStringAppDef_oaInstHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaInstHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaInstHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaInstHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaInstHeader_get,METH_VARARGS,oaStringAppDef_oaInstHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaInstHeader_getDefault,METH_VARARGS,oaStringAppDef_oaInstHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaInstHeader_set,METH_VARARGS,oaStringAppDef_oaInstHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaInstHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaInstHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaInstHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaInstHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_doc[] = 
"Class: oaStringAppDef_oaInstHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaInstHeader)\n"
"    Calls: (const oaStringAppDef_oaInstHeader&)\n"
"    Signature: oaStringAppDef_oaInstHeader||cref-oaStringAppDef_oaInstHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaInstHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaInstHeader",
    sizeof(PyoaStringAppDef_oaInstHeaderObject),
    0,
    (destructor)oaStringAppDef_oaInstHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaInstHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaInstHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaInstHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaInstHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaInstHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInstHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaInstHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInstHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::find(p1.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInstHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaInstHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaInstHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstHeaderp result= (oaStringAppDef_oaInstHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaInstHeader_FromoaStringAppDef_oaInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInstHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaInstHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaInstHeader_static_find,METH_VARARGS,oaStringAppDef_oaInstHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaInstHeader_static_get,METH_VARARGS,oaStringAppDef_oaInstHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaInstHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaInstHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaInstHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaInstHeader",
           (PyObject*)(&PyoaStringAppDef_oaInstHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaInstHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaInstHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaInstHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaInstTerm
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInstTerm_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaInstTerm_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaInstTermObject* self = (PyoaStringAppDef_oaInstTermObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaInstTerm)
    {
        PyParamoaStringAppDef_oaInstTerm p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaInstTerm_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaInstTerm, Choices are:\n"
        "    (oaStringAppDef_oaInstTerm)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaInstTerm_tp_dealloc(PyoaStringAppDef_oaInstTermObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaInstTerm_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaInstTerm value;
    int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[47];
    sprintf(buffer,"<oaStringAppDef_oaInstTerm::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaInstTerm_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaInstTerm v1;
    PyParamoaStringAppDef_oaInstTerm v2;
    int convert_status1=PyoaStringAppDef_oaInstTerm_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaInstTerm_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaInstTerm_Convert(PyObject* ob,PyParamoaStringAppDef_oaInstTerm* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaInstTerm_Check(ob)) {
        result->SetData( (oaStringAppDef_oaInstTerm**) ((PyoaStringAppDef_oaInstTermObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaInstTerm Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(oaStringAppDef_oaInstTerm** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaInstTerm* data=*value;
        PyObject* bself = PyoaStringAppDef_oaInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaInstTerm_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaInstTermObject* self = (PyoaStringAppDef_oaInstTermObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(oaStringAppDef_oaInstTerm* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaInstTerm_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaInstTermObject* self = (PyoaStringAppDef_oaInstTermObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_get_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: get\n"
"  Paramegers: (oaInstTerm,oaString)\n"
"    Calls: void get(const oaInstTerm* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaInstTerm,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstTerm data;
    int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstTermObject* self=(PyoaStringAppDef_oaInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_getDefault_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstTerm data;
    int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstTermObject* self=(PyoaStringAppDef_oaInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_set_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: set\n"
"  Paramegers: (oaInstTerm,oaString)\n"
"    Calls: void set(oaInstTerm* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaInstTerm,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaInstTerm data;
    int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaInstTermObject* self=(PyoaStringAppDef_oaInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_isNull_doc[] =
"Class: oaStringAppDef_oaInstTerm, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaInstTerm data;
    int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaInstTerm_assign_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaInstTerm data;
  int convert_status=PyoaStringAppDef_oaInstTerm_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaInstTerm p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaInstTerm_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaInstTerm_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaInstTerm_get,METH_VARARGS,oaStringAppDef_oaInstTerm_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaInstTerm_getDefault,METH_VARARGS,oaStringAppDef_oaInstTerm_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaInstTerm_set,METH_VARARGS,oaStringAppDef_oaInstTerm_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaInstTerm_tp_isNull,METH_VARARGS,oaStringAppDef_oaInstTerm_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaInstTerm_tp_assign,METH_VARARGS,oaStringAppDef_oaInstTerm_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_doc[] = 
"Class: oaStringAppDef_oaInstTerm\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaInstTerm)\n"
"    Calls: (const oaStringAppDef_oaInstTerm&)\n"
"    Signature: oaStringAppDef_oaInstTerm||cref-oaStringAppDef_oaInstTerm,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaInstTerm_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaInstTerm",
    sizeof(PyoaStringAppDef_oaInstTermObject),
    0,
    (destructor)oaStringAppDef_oaInstTerm_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaInstTerm_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaInstTerm_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaInstTerm_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaInstTerm_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaInstTerm_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_static_find_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInstTerm* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaInstTerm|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInstTerm* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::find(p1.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInstTerm, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaInstTerm_static_get_doc[] = 
"Class: oaStringAppDef_oaInstTerm, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaInstTerm_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaInstTermp result= (oaStringAppDef_oaInstTerm::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaInstTerm_FromoaStringAppDef_oaInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaInstTerm, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaInstTerm_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaInstTerm_static_find,METH_VARARGS,oaStringAppDef_oaInstTerm_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaInstTerm_static_get,METH_VARARGS,oaStringAppDef_oaInstTerm_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaInstTerm_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaInstTerm_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaInstTerm\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaInstTerm",
           (PyObject*)(&PyoaStringAppDef_oaInstTerm_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaInstTerm\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaInstTerm_Type.tp_dict;
    for(method=oaStringAppDef_oaInstTerm_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaLPPHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLPPHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaLPPHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaLPPHeaderObject* self = (PyoaStringAppDef_oaLPPHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaLPPHeader)
    {
        PyParamoaStringAppDef_oaLPPHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaLPPHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaLPPHeader, Choices are:\n"
        "    (oaStringAppDef_oaLPPHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaLPPHeader_tp_dealloc(PyoaStringAppDef_oaLPPHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLPPHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaLPPHeader value;
    int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[48];
    sprintf(buffer,"<oaStringAppDef_oaLPPHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaLPPHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaLPPHeader v1;
    PyParamoaStringAppDef_oaLPPHeader v2;
    int convert_status1=PyoaStringAppDef_oaLPPHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaLPPHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaLPPHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaLPPHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaLPPHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaLPPHeader**) ((PyoaStringAppDef_oaLPPHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaLPPHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(oaStringAppDef_oaLPPHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaLPPHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaLPPHeader_Type.tp_alloc(&PyoaStringAppDef_oaLPPHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaLPPHeaderObject* self = (PyoaStringAppDef_oaLPPHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(oaStringAppDef_oaLPPHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaLPPHeader_Type.tp_alloc(&PyoaStringAppDef_oaLPPHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaLPPHeaderObject* self = (PyoaStringAppDef_oaLPPHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_get_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: get\n"
"  Paramegers: (oaLPPHeader,oaString)\n"
"    Calls: void get(const oaLPPHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaLPPHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLPPHeader data;
    int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLPPHeaderObject* self=(PyoaStringAppDef_oaLPPHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLPPHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLPPHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLPPHeader data;
    int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLPPHeaderObject* self=(PyoaStringAppDef_oaLPPHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_set_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: set\n"
"  Paramegers: (oaLPPHeader,oaString)\n"
"    Calls: void set(oaLPPHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaLPPHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLPPHeader data;
    int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLPPHeaderObject* self=(PyoaStringAppDef_oaLPPHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLPPHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLPPHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_isNull_doc[] =
"Class: oaStringAppDef_oaLPPHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaLPPHeader data;
    int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaLPPHeader_assign_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaLPPHeader data;
  int convert_status=PyoaStringAppDef_oaLPPHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaLPPHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaLPPHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaLPPHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaLPPHeader_get,METH_VARARGS,oaStringAppDef_oaLPPHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaLPPHeader_getDefault,METH_VARARGS,oaStringAppDef_oaLPPHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaLPPHeader_set,METH_VARARGS,oaStringAppDef_oaLPPHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaLPPHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaLPPHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaLPPHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaLPPHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_doc[] = 
"Class: oaStringAppDef_oaLPPHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaLPPHeader)\n"
"    Calls: (const oaStringAppDef_oaLPPHeader&)\n"
"    Signature: oaStringAppDef_oaLPPHeader||cref-oaStringAppDef_oaLPPHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaLPPHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaLPPHeader",
    sizeof(PyoaStringAppDef_oaLPPHeaderObject),
    0,
    (destructor)oaStringAppDef_oaLPPHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaLPPHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaLPPHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaLPPHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaLPPHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaLPPHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLPPHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLPPHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::find(p1.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLPPHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLPPHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaLPPHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLPPHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLPPHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaLPPHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLPPHeaderp result= (oaStringAppDef_oaLPPHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaLPPHeader_FromoaStringAppDef_oaLPPHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLPPHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaLPPHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaLPPHeader_static_find,METH_VARARGS,oaStringAppDef_oaLPPHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaLPPHeader_static_get,METH_VARARGS,oaStringAppDef_oaLPPHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaLPPHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaLPPHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaLPPHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaLPPHeader",
           (PyObject*)(&PyoaStringAppDef_oaLPPHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaLPPHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaLPPHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaLPPHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaLayer
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLayer_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaLayer_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaLayerObject* self = (PyoaStringAppDef_oaLayerObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaLayer)
    {
        PyParamoaStringAppDef_oaLayer p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaLayer_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaLayer, Choices are:\n"
        "    (oaStringAppDef_oaLayer)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaLayer_tp_dealloc(PyoaStringAppDef_oaLayerObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLayer_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaLayer value;
    int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[44];
    sprintf(buffer,"<oaStringAppDef_oaLayer::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaLayer_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaLayer v1;
    PyParamoaStringAppDef_oaLayer v2;
    int convert_status1=PyoaStringAppDef_oaLayer_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaLayer_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaLayer_Convert(PyObject* ob,PyParamoaStringAppDef_oaLayer* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaLayer_Check(ob)) {
        result->SetData( (oaStringAppDef_oaLayer**) ((PyoaStringAppDef_oaLayerObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaLayer Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(oaStringAppDef_oaLayer** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaLayer* data=*value;
        PyObject* bself = PyoaStringAppDef_oaLayer_Type.tp_alloc(&PyoaStringAppDef_oaLayer_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaLayerObject* self = (PyoaStringAppDef_oaLayerObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(oaStringAppDef_oaLayer* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaLayer_Type.tp_alloc(&PyoaStringAppDef_oaLayer_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaLayerObject* self = (PyoaStringAppDef_oaLayerObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_get_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: get\n"
"  Paramegers: (oaLayer,oaString)\n"
"    Calls: void get(const oaLayer* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaLayer,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLayer_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayer data;
    int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerObject* self=(PyoaStringAppDef_oaLayerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLayer p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLayer_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_getDefault_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaLayer_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayer data;
    int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerObject* self=(PyoaStringAppDef_oaLayerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_set_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: set\n"
"  Paramegers: (oaLayer,oaString)\n"
"    Calls: void set(oaLayer* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaLayer,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLayer_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayer data;
    int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerObject* self=(PyoaStringAppDef_oaLayerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLayer p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLayer_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_isNull_doc[] =
"Class: oaStringAppDef_oaLayer, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaLayer_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaLayer data;
    int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaLayer_assign_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaLayer_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaLayer data;
  int convert_status=PyoaStringAppDef_oaLayer_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaLayer p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaLayer_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaLayer_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaLayer_get,METH_VARARGS,oaStringAppDef_oaLayer_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaLayer_getDefault,METH_VARARGS,oaStringAppDef_oaLayer_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaLayer_set,METH_VARARGS,oaStringAppDef_oaLayer_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaLayer_tp_isNull,METH_VARARGS,oaStringAppDef_oaLayer_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaLayer_tp_assign,METH_VARARGS,oaStringAppDef_oaLayer_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_doc[] = 
"Class: oaStringAppDef_oaLayer\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaLayer)\n"
"    Calls: (const oaStringAppDef_oaLayer&)\n"
"    Signature: oaStringAppDef_oaLayer||cref-oaStringAppDef_oaLayer,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaLayer_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaLayer",
    sizeof(PyoaStringAppDef_oaLayerObject),
    0,
    (destructor)oaStringAppDef_oaLayer_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaLayer_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaLayer_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaLayer_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaLayer_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaLayer_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_static_find_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLayer* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaLayer|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLayer* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaLayer|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaLayer_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::find(p1.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLayer, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayer_static_get_doc[] = 
"Class: oaStringAppDef_oaLayer, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLayer* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayer|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaLayer_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerp result= (oaStringAppDef_oaLayer::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaLayer_FromoaStringAppDef_oaLayer(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLayer, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaLayer_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaLayer_static_find,METH_VARARGS,oaStringAppDef_oaLayer_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaLayer_static_get,METH_VARARGS,oaStringAppDef_oaLayer_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaLayer_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaLayer_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaLayer\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaLayer",
           (PyObject*)(&PyoaStringAppDef_oaLayer_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaLayer\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaLayer_Type.tp_dict;
    for(method=oaStringAppDef_oaLayer_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaLayerHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLayerHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaLayerHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaLayerHeaderObject* self = (PyoaStringAppDef_oaLayerHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaLayerHeader)
    {
        PyParamoaStringAppDef_oaLayerHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaLayerHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaLayerHeader, Choices are:\n"
        "    (oaStringAppDef_oaLayerHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaLayerHeader_tp_dealloc(PyoaStringAppDef_oaLayerHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLayerHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaLayerHeader value;
    int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaLayerHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaLayerHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaLayerHeader v1;
    PyParamoaStringAppDef_oaLayerHeader v2;
    int convert_status1=PyoaStringAppDef_oaLayerHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaLayerHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaLayerHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaLayerHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaLayerHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaLayerHeader**) ((PyoaStringAppDef_oaLayerHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaLayerHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(oaStringAppDef_oaLayerHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaLayerHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaLayerHeader_Type.tp_alloc(&PyoaStringAppDef_oaLayerHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaLayerHeaderObject* self = (PyoaStringAppDef_oaLayerHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(oaStringAppDef_oaLayerHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaLayerHeader_Type.tp_alloc(&PyoaStringAppDef_oaLayerHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaLayerHeaderObject* self = (PyoaStringAppDef_oaLayerHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_get_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: get\n"
"  Paramegers: (oaLayerHeader,oaString)\n"
"    Calls: void get(const oaLayerHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaLayerHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayerHeader data;
    int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerHeaderObject* self=(PyoaStringAppDef_oaLayerHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLayerHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLayerHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayerHeader data;
    int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerHeaderObject* self=(PyoaStringAppDef_oaLayerHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_set_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: set\n"
"  Paramegers: (oaLayerHeader,oaString)\n"
"    Calls: void set(oaLayerHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaLayerHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLayerHeader data;
    int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLayerHeaderObject* self=(PyoaStringAppDef_oaLayerHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLayerHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLayerHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_isNull_doc[] =
"Class: oaStringAppDef_oaLayerHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaLayerHeader data;
    int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaLayerHeader_assign_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaLayerHeader data;
  int convert_status=PyoaStringAppDef_oaLayerHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaLayerHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaLayerHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaLayerHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaLayerHeader_get,METH_VARARGS,oaStringAppDef_oaLayerHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaLayerHeader_getDefault,METH_VARARGS,oaStringAppDef_oaLayerHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaLayerHeader_set,METH_VARARGS,oaStringAppDef_oaLayerHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaLayerHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaLayerHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaLayerHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaLayerHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_doc[] = 
"Class: oaStringAppDef_oaLayerHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaLayerHeader)\n"
"    Calls: (const oaStringAppDef_oaLayerHeader&)\n"
"    Signature: oaStringAppDef_oaLayerHeader||cref-oaStringAppDef_oaLayerHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaLayerHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaLayerHeader",
    sizeof(PyoaStringAppDef_oaLayerHeaderObject),
    0,
    (destructor)oaStringAppDef_oaLayerHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaLayerHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaLayerHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaLayerHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaLayerHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaLayerHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLayerHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLayerHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::find(p1.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLayerHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLayerHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaLayerHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLayerHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLayerHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaLayerHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLayerHeaderp result= (oaStringAppDef_oaLayerHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaLayerHeader_FromoaStringAppDef_oaLayerHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLayerHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaLayerHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaLayerHeader_static_find,METH_VARARGS,oaStringAppDef_oaLayerHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaLayerHeader_static_get,METH_VARARGS,oaStringAppDef_oaLayerHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaLayerHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaLayerHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaLayerHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaLayerHeader",
           (PyObject*)(&PyoaStringAppDef_oaLayerHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaLayerHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaLayerHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaLayerHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaLib
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLib_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaLib_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaLibObject* self = (PyoaStringAppDef_oaLibObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaLib)
    {
        PyParamoaStringAppDef_oaLib p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaLib_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaLib, Choices are:\n"
        "    (oaStringAppDef_oaLib)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaLib_tp_dealloc(PyoaStringAppDef_oaLibObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaLib_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaLib value;
    int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[42];
    sprintf(buffer,"<oaStringAppDef_oaLib::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaLib_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaLib v1;
    PyParamoaStringAppDef_oaLib v2;
    int convert_status1=PyoaStringAppDef_oaLib_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaLib_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaLib_Convert(PyObject* ob,PyParamoaStringAppDef_oaLib* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaLib_Check(ob)) {
        result->SetData( (oaStringAppDef_oaLib**) ((PyoaStringAppDef_oaLibObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaLib Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(oaStringAppDef_oaLib** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaLib* data=*value;
        PyObject* bself = PyoaStringAppDef_oaLib_Type.tp_alloc(&PyoaStringAppDef_oaLib_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaLibObject* self = (PyoaStringAppDef_oaLibObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(oaStringAppDef_oaLib* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaLib_Type.tp_alloc(&PyoaStringAppDef_oaLib_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaLibObject* self = (PyoaStringAppDef_oaLibObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_get_doc[] = 
"Class: oaStringAppDef_oaLib, Function: get\n"
"  Paramegers: (oaLib,oaString)\n"
"    Calls: void get(const oaLib* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaLib,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLib_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLib data;
    int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLibObject* self=(PyoaStringAppDef_oaLibObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLib p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLib_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_getDefault_doc[] = 
"Class: oaStringAppDef_oaLib, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaLib_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLib data;
    int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLibObject* self=(PyoaStringAppDef_oaLibObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_set_doc[] = 
"Class: oaStringAppDef_oaLib, Function: set\n"
"  Paramegers: (oaLib,oaString)\n"
"    Calls: void set(oaLib* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaLib,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaLib_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaLib data;
    int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaLibObject* self=(PyoaStringAppDef_oaLibObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaLib p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaLib_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_isNull_doc[] =
"Class: oaStringAppDef_oaLib, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaLib_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaLib data;
    int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaLib_assign_doc[] = 
"Class: oaStringAppDef_oaLib, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaLib_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaLib data;
  int convert_status=PyoaStringAppDef_oaLib_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaLib p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaLib_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaLib_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaLib_get,METH_VARARGS,oaStringAppDef_oaLib_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaLib_getDefault,METH_VARARGS,oaStringAppDef_oaLib_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaLib_set,METH_VARARGS,oaStringAppDef_oaLib_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaLib_tp_isNull,METH_VARARGS,oaStringAppDef_oaLib_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaLib_tp_assign,METH_VARARGS,oaStringAppDef_oaLib_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_doc[] = 
"Class: oaStringAppDef_oaLib\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaLib)\n"
"    Calls: (const oaStringAppDef_oaLib&)\n"
"    Signature: oaStringAppDef_oaLib||cref-oaStringAppDef_oaLib,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaLib_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaLib",
    sizeof(PyoaStringAppDef_oaLibObject),
    0,
    (destructor)oaStringAppDef_oaLib_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaLib_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaLib_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaLib_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaLib_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaLib_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_static_find_doc[] = 
"Class: oaStringAppDef_oaLib, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLib* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaLib|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLib* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaLib|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaLib_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::find(p1.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLib, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaLib_static_get_doc[] = 
"Class: oaStringAppDef_oaLib, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaLib* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaLib|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaLib_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaLibp result= (oaStringAppDef_oaLib::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaLib_FromoaStringAppDef_oaLib(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaLib, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaLib_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaLib_static_find,METH_VARARGS,oaStringAppDef_oaLib_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaLib_static_get,METH_VARARGS,oaStringAppDef_oaLib_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaLib_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaLib_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaLib\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaLib",
           (PyObject*)(&PyoaStringAppDef_oaLib_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaLib\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaLib_Type.tp_dict;
    for(method=oaStringAppDef_oaLib_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaMarker
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaMarker_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaMarker_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaMarkerObject* self = (PyoaStringAppDef_oaMarkerObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaMarker)
    {
        PyParamoaStringAppDef_oaMarker p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaMarker_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaMarker, Choices are:\n"
        "    (oaStringAppDef_oaMarker)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaMarker_tp_dealloc(PyoaStringAppDef_oaMarkerObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaMarker_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaMarker value;
    int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[45];
    sprintf(buffer,"<oaStringAppDef_oaMarker::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaMarker_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaMarker v1;
    PyParamoaStringAppDef_oaMarker v2;
    int convert_status1=PyoaStringAppDef_oaMarker_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaMarker_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaMarker_Convert(PyObject* ob,PyParamoaStringAppDef_oaMarker* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaMarker_Check(ob)) {
        result->SetData( (oaStringAppDef_oaMarker**) ((PyoaStringAppDef_oaMarkerObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaMarker Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(oaStringAppDef_oaMarker** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaMarker* data=*value;
        PyObject* bself = PyoaStringAppDef_oaMarker_Type.tp_alloc(&PyoaStringAppDef_oaMarker_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaMarkerObject* self = (PyoaStringAppDef_oaMarkerObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(oaStringAppDef_oaMarker* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaMarker_Type.tp_alloc(&PyoaStringAppDef_oaMarker_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaMarkerObject* self = (PyoaStringAppDef_oaMarkerObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_get_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: get\n"
"  Paramegers: (oaMarker,oaString)\n"
"    Calls: void get(const oaMarker* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaMarker,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaMarker_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaMarker data;
    int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaMarkerObject* self=(PyoaStringAppDef_oaMarkerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaMarker p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaMarker_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_getDefault_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaMarker_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaMarker data;
    int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaMarkerObject* self=(PyoaStringAppDef_oaMarkerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_set_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: set\n"
"  Paramegers: (oaMarker,oaString)\n"
"    Calls: void set(oaMarker* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaMarker,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaMarker_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaMarker data;
    int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaMarkerObject* self=(PyoaStringAppDef_oaMarkerObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaMarker p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaMarker_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_isNull_doc[] =
"Class: oaStringAppDef_oaMarker, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaMarker_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaMarker data;
    int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaMarker_assign_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaMarker_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaMarker data;
  int convert_status=PyoaStringAppDef_oaMarker_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaMarker p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaMarker_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaMarker_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaMarker_get,METH_VARARGS,oaStringAppDef_oaMarker_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaMarker_getDefault,METH_VARARGS,oaStringAppDef_oaMarker_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaMarker_set,METH_VARARGS,oaStringAppDef_oaMarker_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaMarker_tp_isNull,METH_VARARGS,oaStringAppDef_oaMarker_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaMarker_tp_assign,METH_VARARGS,oaStringAppDef_oaMarker_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_doc[] = 
"Class: oaStringAppDef_oaMarker\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaMarker)\n"
"    Calls: (const oaStringAppDef_oaMarker&)\n"
"    Signature: oaStringAppDef_oaMarker||cref-oaStringAppDef_oaMarker,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaMarker_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaMarker",
    sizeof(PyoaStringAppDef_oaMarkerObject),
    0,
    (destructor)oaStringAppDef_oaMarker_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaMarker_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaMarker_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaMarker_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaMarker_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaMarker_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_static_find_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaMarker* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaMarker|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaMarker* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaMarker|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaMarker_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::find(p1.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaMarker, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaMarker_static_get_doc[] = 
"Class: oaStringAppDef_oaMarker, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaMarker* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaMarker|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaMarker_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaMarkerp result= (oaStringAppDef_oaMarker::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaMarker_FromoaStringAppDef_oaMarker(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaMarker, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaMarker_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaMarker_static_find,METH_VARARGS,oaStringAppDef_oaMarker_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaMarker_static_get,METH_VARARGS,oaStringAppDef_oaMarker_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaMarker_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaMarker_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaMarker\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaMarker",
           (PyObject*)(&PyoaStringAppDef_oaMarker_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaMarker\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaMarker_Type.tp_dict;
    for(method=oaStringAppDef_oaMarker_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModAssignment
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModAssignment_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModAssignment_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModAssignmentObject* self = (PyoaStringAppDef_oaModAssignmentObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModAssignment)
    {
        PyParamoaStringAppDef_oaModAssignment p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModAssignment_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModAssignment, Choices are:\n"
        "    (oaStringAppDef_oaModAssignment)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModAssignment_tp_dealloc(PyoaStringAppDef_oaModAssignmentObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModAssignment_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModAssignment value;
    int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaModAssignment::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModAssignment_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModAssignment v1;
    PyParamoaStringAppDef_oaModAssignment v2;
    int convert_status1=PyoaStringAppDef_oaModAssignment_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModAssignment_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModAssignment_Convert(PyObject* ob,PyParamoaStringAppDef_oaModAssignment* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModAssignment_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModAssignment**) ((PyoaStringAppDef_oaModAssignmentObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModAssignment Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(oaStringAppDef_oaModAssignment** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModAssignment* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModAssignment_Type.tp_alloc(&PyoaStringAppDef_oaModAssignment_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModAssignmentObject* self = (PyoaStringAppDef_oaModAssignmentObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(oaStringAppDef_oaModAssignment* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModAssignment_Type.tp_alloc(&PyoaStringAppDef_oaModAssignment_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModAssignmentObject* self = (PyoaStringAppDef_oaModAssignmentObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_get_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: get\n"
"  Paramegers: (oaModAssignment,oaString)\n"
"    Calls: void get(const oaModAssignment* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModAssignment,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModAssignment data;
    int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModAssignmentObject* self=(PyoaStringAppDef_oaModAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModAssignment p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModAssignment_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_getDefault_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModAssignment data;
    int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModAssignmentObject* self=(PyoaStringAppDef_oaModAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_set_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: set\n"
"  Paramegers: (oaModAssignment,oaString)\n"
"    Calls: void set(oaModAssignment* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModAssignment,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModAssignment data;
    int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModAssignmentObject* self=(PyoaStringAppDef_oaModAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModAssignment p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModAssignment_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_isNull_doc[] =
"Class: oaStringAppDef_oaModAssignment, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModAssignment data;
    int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModAssignment_assign_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModAssignment data;
  int convert_status=PyoaStringAppDef_oaModAssignment_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModAssignment p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModAssignment_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModAssignment_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModAssignment_get,METH_VARARGS,oaStringAppDef_oaModAssignment_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModAssignment_getDefault,METH_VARARGS,oaStringAppDef_oaModAssignment_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModAssignment_set,METH_VARARGS,oaStringAppDef_oaModAssignment_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModAssignment_tp_isNull,METH_VARARGS,oaStringAppDef_oaModAssignment_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModAssignment_tp_assign,METH_VARARGS,oaStringAppDef_oaModAssignment_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_doc[] = 
"Class: oaStringAppDef_oaModAssignment\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModAssignment)\n"
"    Calls: (const oaStringAppDef_oaModAssignment&)\n"
"    Signature: oaStringAppDef_oaModAssignment||cref-oaStringAppDef_oaModAssignment,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModAssignment_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModAssignment",
    sizeof(PyoaStringAppDef_oaModAssignmentObject),
    0,
    (destructor)oaStringAppDef_oaModAssignment_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModAssignment_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModAssignment_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModAssignment_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModAssignment_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModAssignment_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_static_find_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModAssignment* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModAssignment|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModAssignment* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::find(p1.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModAssignment, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModAssignment_static_get_doc[] = 
"Class: oaStringAppDef_oaModAssignment, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModAssignment* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModAssignment_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModAssignmentp result= (oaStringAppDef_oaModAssignment::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModAssignment_FromoaStringAppDef_oaModAssignment(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModAssignment, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModAssignment_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModAssignment_static_find,METH_VARARGS,oaStringAppDef_oaModAssignment_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModAssignment_static_get,METH_VARARGS,oaStringAppDef_oaModAssignment_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModAssignment_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModAssignment_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModAssignment\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModAssignment",
           (PyObject*)(&PyoaStringAppDef_oaModAssignment_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModAssignment\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModAssignment_Type.tp_dict;
    for(method=oaStringAppDef_oaModAssignment_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModBusNetDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModBusNetDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModBusNetDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModBusNetDefObject* self = (PyoaStringAppDef_oaModBusNetDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModBusNetDef)
    {
        PyParamoaStringAppDef_oaModBusNetDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModBusNetDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModBusNetDef, Choices are:\n"
        "    (oaStringAppDef_oaModBusNetDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModBusNetDef_tp_dealloc(PyoaStringAppDef_oaModBusNetDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModBusNetDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModBusNetDef value;
    int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[51];
    sprintf(buffer,"<oaStringAppDef_oaModBusNetDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModBusNetDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModBusNetDef v1;
    PyParamoaStringAppDef_oaModBusNetDef v2;
    int convert_status1=PyoaStringAppDef_oaModBusNetDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModBusNetDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModBusNetDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaModBusNetDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModBusNetDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModBusNetDef**) ((PyoaStringAppDef_oaModBusNetDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModBusNetDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(oaStringAppDef_oaModBusNetDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModBusNetDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModBusNetDef_Type.tp_alloc(&PyoaStringAppDef_oaModBusNetDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModBusNetDefObject* self = (PyoaStringAppDef_oaModBusNetDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(oaStringAppDef_oaModBusNetDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModBusNetDef_Type.tp_alloc(&PyoaStringAppDef_oaModBusNetDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModBusNetDefObject* self = (PyoaStringAppDef_oaModBusNetDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_get_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: get\n"
"  Paramegers: (oaModBusNetDef,oaString)\n"
"    Calls: void get(const oaModBusNetDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModBusNetDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusNetDef data;
    int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusNetDefObject* self=(PyoaStringAppDef_oaModBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModBusNetDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModBusNetDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusNetDef data;
    int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusNetDefObject* self=(PyoaStringAppDef_oaModBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_set_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: set\n"
"  Paramegers: (oaModBusNetDef,oaString)\n"
"    Calls: void set(oaModBusNetDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModBusNetDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusNetDef data;
    int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusNetDefObject* self=(PyoaStringAppDef_oaModBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModBusNetDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModBusNetDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_isNull_doc[] =
"Class: oaStringAppDef_oaModBusNetDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModBusNetDef data;
    int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModBusNetDef_assign_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModBusNetDef data;
  int convert_status=PyoaStringAppDef_oaModBusNetDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModBusNetDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModBusNetDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModBusNetDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModBusNetDef_get,METH_VARARGS,oaStringAppDef_oaModBusNetDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModBusNetDef_getDefault,METH_VARARGS,oaStringAppDef_oaModBusNetDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModBusNetDef_set,METH_VARARGS,oaStringAppDef_oaModBusNetDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModBusNetDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaModBusNetDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModBusNetDef_tp_assign,METH_VARARGS,oaStringAppDef_oaModBusNetDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModBusNetDef)\n"
"    Calls: (const oaStringAppDef_oaModBusNetDef&)\n"
"    Signature: oaStringAppDef_oaModBusNetDef||cref-oaStringAppDef_oaModBusNetDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModBusNetDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModBusNetDef",
    sizeof(PyoaStringAppDef_oaModBusNetDefObject),
    0,
    (destructor)oaStringAppDef_oaModBusNetDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModBusNetDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModBusNetDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModBusNetDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModBusNetDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModBusNetDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_static_find_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::find(p1.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModBusNetDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusNetDef_static_get_doc[] = 
"Class: oaStringAppDef_oaModBusNetDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModBusNetDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusNetDefp result= (oaStringAppDef_oaModBusNetDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModBusNetDef_FromoaStringAppDef_oaModBusNetDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModBusNetDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModBusNetDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModBusNetDef_static_find,METH_VARARGS,oaStringAppDef_oaModBusNetDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModBusNetDef_static_get,METH_VARARGS,oaStringAppDef_oaModBusNetDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModBusNetDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModBusNetDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModBusNetDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModBusNetDef",
           (PyObject*)(&PyoaStringAppDef_oaModBusNetDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModBusNetDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModBusNetDef_Type.tp_dict;
    for(method=oaStringAppDef_oaModBusNetDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModBusTermDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModBusTermDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModBusTermDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModBusTermDefObject* self = (PyoaStringAppDef_oaModBusTermDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModBusTermDef)
    {
        PyParamoaStringAppDef_oaModBusTermDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModBusTermDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModBusTermDef, Choices are:\n"
        "    (oaStringAppDef_oaModBusTermDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModBusTermDef_tp_dealloc(PyoaStringAppDef_oaModBusTermDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModBusTermDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModBusTermDef value;
    int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaModBusTermDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModBusTermDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModBusTermDef v1;
    PyParamoaStringAppDef_oaModBusTermDef v2;
    int convert_status1=PyoaStringAppDef_oaModBusTermDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModBusTermDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModBusTermDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaModBusTermDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModBusTermDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModBusTermDef**) ((PyoaStringAppDef_oaModBusTermDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModBusTermDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(oaStringAppDef_oaModBusTermDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModBusTermDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModBusTermDef_Type.tp_alloc(&PyoaStringAppDef_oaModBusTermDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModBusTermDefObject* self = (PyoaStringAppDef_oaModBusTermDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(oaStringAppDef_oaModBusTermDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModBusTermDef_Type.tp_alloc(&PyoaStringAppDef_oaModBusTermDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModBusTermDefObject* self = (PyoaStringAppDef_oaModBusTermDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_get_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: get\n"
"  Paramegers: (oaModBusTermDef,oaString)\n"
"    Calls: void get(const oaModBusTermDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModBusTermDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusTermDef data;
    int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusTermDefObject* self=(PyoaStringAppDef_oaModBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModBusTermDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModBusTermDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusTermDef data;
    int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusTermDefObject* self=(PyoaStringAppDef_oaModBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_set_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: set\n"
"  Paramegers: (oaModBusTermDef,oaString)\n"
"    Calls: void set(oaModBusTermDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModBusTermDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModBusTermDef data;
    int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModBusTermDefObject* self=(PyoaStringAppDef_oaModBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModBusTermDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModBusTermDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_isNull_doc[] =
"Class: oaStringAppDef_oaModBusTermDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModBusTermDef data;
    int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModBusTermDef_assign_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModBusTermDef data;
  int convert_status=PyoaStringAppDef_oaModBusTermDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModBusTermDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModBusTermDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModBusTermDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModBusTermDef_get,METH_VARARGS,oaStringAppDef_oaModBusTermDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModBusTermDef_getDefault,METH_VARARGS,oaStringAppDef_oaModBusTermDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModBusTermDef_set,METH_VARARGS,oaStringAppDef_oaModBusTermDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModBusTermDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaModBusTermDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModBusTermDef_tp_assign,METH_VARARGS,oaStringAppDef_oaModBusTermDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModBusTermDef)\n"
"    Calls: (const oaStringAppDef_oaModBusTermDef&)\n"
"    Signature: oaStringAppDef_oaModBusTermDef||cref-oaStringAppDef_oaModBusTermDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModBusTermDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModBusTermDef",
    sizeof(PyoaStringAppDef_oaModBusTermDefObject),
    0,
    (destructor)oaStringAppDef_oaModBusTermDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModBusTermDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModBusTermDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModBusTermDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModBusTermDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModBusTermDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_static_find_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::find(p1.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModBusTermDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModBusTermDef_static_get_doc[] = 
"Class: oaStringAppDef_oaModBusTermDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModBusTermDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModBusTermDefp result= (oaStringAppDef_oaModBusTermDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModBusTermDef_FromoaStringAppDef_oaModBusTermDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModBusTermDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModBusTermDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModBusTermDef_static_find,METH_VARARGS,oaStringAppDef_oaModBusTermDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModBusTermDef_static_get,METH_VARARGS,oaStringAppDef_oaModBusTermDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModBusTermDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModBusTermDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModBusTermDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModBusTermDef",
           (PyObject*)(&PyoaStringAppDef_oaModBusTermDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModBusTermDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModBusTermDef_Type.tp_dict;
    for(method=oaStringAppDef_oaModBusTermDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModConnectDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModConnectDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModConnectDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModConnectDefObject* self = (PyoaStringAppDef_oaModConnectDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModConnectDef)
    {
        PyParamoaStringAppDef_oaModConnectDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModConnectDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModConnectDef, Choices are:\n"
        "    (oaStringAppDef_oaModConnectDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModConnectDef_tp_dealloc(PyoaStringAppDef_oaModConnectDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModConnectDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModConnectDef value;
    int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaModConnectDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModConnectDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModConnectDef v1;
    PyParamoaStringAppDef_oaModConnectDef v2;
    int convert_status1=PyoaStringAppDef_oaModConnectDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModConnectDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModConnectDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaModConnectDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModConnectDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModConnectDef**) ((PyoaStringAppDef_oaModConnectDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModConnectDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(oaStringAppDef_oaModConnectDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModConnectDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModConnectDef_Type.tp_alloc(&PyoaStringAppDef_oaModConnectDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModConnectDefObject* self = (PyoaStringAppDef_oaModConnectDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(oaStringAppDef_oaModConnectDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModConnectDef_Type.tp_alloc(&PyoaStringAppDef_oaModConnectDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModConnectDefObject* self = (PyoaStringAppDef_oaModConnectDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_get_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: get\n"
"  Paramegers: (oaModConnectDef,oaString)\n"
"    Calls: void get(const oaModConnectDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModConnectDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModConnectDef data;
    int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModConnectDefObject* self=(PyoaStringAppDef_oaModConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModConnectDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModConnectDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModConnectDef data;
    int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModConnectDefObject* self=(PyoaStringAppDef_oaModConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_set_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: set\n"
"  Paramegers: (oaModConnectDef,oaString)\n"
"    Calls: void set(oaModConnectDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModConnectDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModConnectDef data;
    int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModConnectDefObject* self=(PyoaStringAppDef_oaModConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModConnectDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModConnectDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_isNull_doc[] =
"Class: oaStringAppDef_oaModConnectDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModConnectDef data;
    int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModConnectDef_assign_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModConnectDef data;
  int convert_status=PyoaStringAppDef_oaModConnectDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModConnectDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModConnectDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModConnectDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModConnectDef_get,METH_VARARGS,oaStringAppDef_oaModConnectDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModConnectDef_getDefault,METH_VARARGS,oaStringAppDef_oaModConnectDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModConnectDef_set,METH_VARARGS,oaStringAppDef_oaModConnectDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModConnectDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaModConnectDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModConnectDef_tp_assign,METH_VARARGS,oaStringAppDef_oaModConnectDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_doc[] = 
"Class: oaStringAppDef_oaModConnectDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModConnectDef)\n"
"    Calls: (const oaStringAppDef_oaModConnectDef&)\n"
"    Signature: oaStringAppDef_oaModConnectDef||cref-oaStringAppDef_oaModConnectDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModConnectDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModConnectDef",
    sizeof(PyoaStringAppDef_oaModConnectDefObject),
    0,
    (destructor)oaStringAppDef_oaModConnectDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModConnectDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModConnectDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModConnectDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModConnectDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModConnectDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_static_find_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModConnectDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModConnectDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::find(p1.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModConnectDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModConnectDef_static_get_doc[] = 
"Class: oaStringAppDef_oaModConnectDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModConnectDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModConnectDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModConnectDefp result= (oaStringAppDef_oaModConnectDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModConnectDef_FromoaStringAppDef_oaModConnectDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModConnectDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModConnectDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModConnectDef_static_find,METH_VARARGS,oaStringAppDef_oaModConnectDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModConnectDef_static_get,METH_VARARGS,oaStringAppDef_oaModConnectDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModConnectDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModConnectDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModConnectDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModConnectDef",
           (PyObject*)(&PyoaStringAppDef_oaModConnectDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModConnectDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModConnectDef_Type.tp_dict;
    for(method=oaStringAppDef_oaModConnectDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModInst
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInst_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModInst_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModInstObject* self = (PyoaStringAppDef_oaModInstObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModInst)
    {
        PyParamoaStringAppDef_oaModInst p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModInst_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModInst, Choices are:\n"
        "    (oaStringAppDef_oaModInst)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModInst_tp_dealloc(PyoaStringAppDef_oaModInstObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInst_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModInst value;
    int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[46];
    sprintf(buffer,"<oaStringAppDef_oaModInst::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModInst_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModInst v1;
    PyParamoaStringAppDef_oaModInst v2;
    int convert_status1=PyoaStringAppDef_oaModInst_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModInst_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModInst_Convert(PyObject* ob,PyParamoaStringAppDef_oaModInst* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModInst_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModInst**) ((PyoaStringAppDef_oaModInstObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModInst Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(oaStringAppDef_oaModInst** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModInst* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModInst_Type.tp_alloc(&PyoaStringAppDef_oaModInst_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModInstObject* self = (PyoaStringAppDef_oaModInstObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(oaStringAppDef_oaModInst* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModInst_Type.tp_alloc(&PyoaStringAppDef_oaModInst_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModInstObject* self = (PyoaStringAppDef_oaModInstObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_get_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: get\n"
"  Paramegers: (oaModInst,oaString)\n"
"    Calls: void get(const oaModInst* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModInst,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInst_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInst data;
    int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstObject* self=(PyoaStringAppDef_oaModInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_getDefault_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModInst_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInst data;
    int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstObject* self=(PyoaStringAppDef_oaModInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_set_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: set\n"
"  Paramegers: (oaModInst,oaString)\n"
"    Calls: void set(oaModInst* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModInst,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInst_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInst data;
    int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstObject* self=(PyoaStringAppDef_oaModInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_isNull_doc[] =
"Class: oaStringAppDef_oaModInst, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModInst_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModInst data;
    int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModInst_assign_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModInst_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModInst data;
  int convert_status=PyoaStringAppDef_oaModInst_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModInst p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModInst_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModInst_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModInst_get,METH_VARARGS,oaStringAppDef_oaModInst_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModInst_getDefault,METH_VARARGS,oaStringAppDef_oaModInst_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModInst_set,METH_VARARGS,oaStringAppDef_oaModInst_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModInst_tp_isNull,METH_VARARGS,oaStringAppDef_oaModInst_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModInst_tp_assign,METH_VARARGS,oaStringAppDef_oaModInst_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_doc[] = 
"Class: oaStringAppDef_oaModInst\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModInst)\n"
"    Calls: (const oaStringAppDef_oaModInst&)\n"
"    Signature: oaStringAppDef_oaModInst||cref-oaStringAppDef_oaModInst,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModInst_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModInst",
    sizeof(PyoaStringAppDef_oaModInstObject),
    0,
    (destructor)oaStringAppDef_oaModInst_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModInst_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModInst_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModInst_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModInst_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModInst_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_static_find_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInst* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInst|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInst* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInst|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModInst_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::find(p1.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInst, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInst_static_get_doc[] = 
"Class: oaStringAppDef_oaModInst, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModInst_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstp result= (oaStringAppDef_oaModInst::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModInst_FromoaStringAppDef_oaModInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInst, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModInst_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModInst_static_find,METH_VARARGS,oaStringAppDef_oaModInst_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModInst_static_get,METH_VARARGS,oaStringAppDef_oaModInst_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModInst_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModInst_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModInst\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModInst",
           (PyObject*)(&PyoaStringAppDef_oaModInst_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModInst\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModInst_Type.tp_dict;
    for(method=oaStringAppDef_oaModInst_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModInstHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInstHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModInstHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModInstHeaderObject* self = (PyoaStringAppDef_oaModInstHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModInstHeader)
    {
        PyParamoaStringAppDef_oaModInstHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModInstHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModInstHeader, Choices are:\n"
        "    (oaStringAppDef_oaModInstHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModInstHeader_tp_dealloc(PyoaStringAppDef_oaModInstHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInstHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModInstHeader value;
    int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaModInstHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModInstHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModInstHeader v1;
    PyParamoaStringAppDef_oaModInstHeader v2;
    int convert_status1=PyoaStringAppDef_oaModInstHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModInstHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModInstHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaModInstHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModInstHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModInstHeader**) ((PyoaStringAppDef_oaModInstHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModInstHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(oaStringAppDef_oaModInstHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModInstHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaModInstHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModInstHeaderObject* self = (PyoaStringAppDef_oaModInstHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(oaStringAppDef_oaModInstHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaModInstHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModInstHeaderObject* self = (PyoaStringAppDef_oaModInstHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_get_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: get\n"
"  Paramegers: (oaModInstHeader,oaString)\n"
"    Calls: void get(const oaModInstHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModInstHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstHeader data;
    int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstHeaderObject* self=(PyoaStringAppDef_oaModInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstHeader data;
    int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstHeaderObject* self=(PyoaStringAppDef_oaModInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_set_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: set\n"
"  Paramegers: (oaModInstHeader,oaString)\n"
"    Calls: void set(oaModInstHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModInstHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstHeader data;
    int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstHeaderObject* self=(PyoaStringAppDef_oaModInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_isNull_doc[] =
"Class: oaStringAppDef_oaModInstHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModInstHeader data;
    int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModInstHeader_assign_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModInstHeader data;
  int convert_status=PyoaStringAppDef_oaModInstHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModInstHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModInstHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModInstHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModInstHeader_get,METH_VARARGS,oaStringAppDef_oaModInstHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModInstHeader_getDefault,METH_VARARGS,oaStringAppDef_oaModInstHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModInstHeader_set,METH_VARARGS,oaStringAppDef_oaModInstHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModInstHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaModInstHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModInstHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaModInstHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_doc[] = 
"Class: oaStringAppDef_oaModInstHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModInstHeader)\n"
"    Calls: (const oaStringAppDef_oaModInstHeader&)\n"
"    Signature: oaStringAppDef_oaModInstHeader||cref-oaStringAppDef_oaModInstHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModInstHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModInstHeader",
    sizeof(PyoaStringAppDef_oaModInstHeaderObject),
    0,
    (destructor)oaStringAppDef_oaModInstHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModInstHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModInstHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModInstHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModInstHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModInstHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInstHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInstHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::find(p1.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInstHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaModInstHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModInstHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstHeaderp result= (oaStringAppDef_oaModInstHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModInstHeader_FromoaStringAppDef_oaModInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInstHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModInstHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModInstHeader_static_find,METH_VARARGS,oaStringAppDef_oaModInstHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModInstHeader_static_get,METH_VARARGS,oaStringAppDef_oaModInstHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModInstHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModInstHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModInstHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModInstHeader",
           (PyObject*)(&PyoaStringAppDef_oaModInstHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModInstHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModInstHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaModInstHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModInstTerm
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInstTerm_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModInstTerm_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModInstTermObject* self = (PyoaStringAppDef_oaModInstTermObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModInstTerm)
    {
        PyParamoaStringAppDef_oaModInstTerm p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModInstTerm_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModInstTerm, Choices are:\n"
        "    (oaStringAppDef_oaModInstTerm)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModInstTerm_tp_dealloc(PyoaStringAppDef_oaModInstTermObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModInstTerm_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModInstTerm value;
    int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaModInstTerm::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModInstTerm_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModInstTerm v1;
    PyParamoaStringAppDef_oaModInstTerm v2;
    int convert_status1=PyoaStringAppDef_oaModInstTerm_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModInstTerm_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModInstTerm_Convert(PyObject* ob,PyParamoaStringAppDef_oaModInstTerm* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModInstTerm_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModInstTerm**) ((PyoaStringAppDef_oaModInstTermObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModInstTerm Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(oaStringAppDef_oaModInstTerm** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModInstTerm* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaModInstTerm_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModInstTermObject* self = (PyoaStringAppDef_oaModInstTermObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(oaStringAppDef_oaModInstTerm* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaModInstTerm_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModInstTermObject* self = (PyoaStringAppDef_oaModInstTermObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_get_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: get\n"
"  Paramegers: (oaModInstTerm,oaString)\n"
"    Calls: void get(const oaModInstTerm* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModInstTerm,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstTerm data;
    int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstTermObject* self=(PyoaStringAppDef_oaModInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_getDefault_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstTerm data;
    int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstTermObject* self=(PyoaStringAppDef_oaModInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_set_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: set\n"
"  Paramegers: (oaModInstTerm,oaString)\n"
"    Calls: void set(oaModInstTerm* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModInstTerm,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModInstTerm data;
    int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModInstTermObject* self=(PyoaStringAppDef_oaModInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_isNull_doc[] =
"Class: oaStringAppDef_oaModInstTerm, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModInstTerm data;
    int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModInstTerm_assign_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModInstTerm data;
  int convert_status=PyoaStringAppDef_oaModInstTerm_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModInstTerm p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModInstTerm_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModInstTerm_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModInstTerm_get,METH_VARARGS,oaStringAppDef_oaModInstTerm_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModInstTerm_getDefault,METH_VARARGS,oaStringAppDef_oaModInstTerm_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModInstTerm_set,METH_VARARGS,oaStringAppDef_oaModInstTerm_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModInstTerm_tp_isNull,METH_VARARGS,oaStringAppDef_oaModInstTerm_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModInstTerm_tp_assign,METH_VARARGS,oaStringAppDef_oaModInstTerm_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_doc[] = 
"Class: oaStringAppDef_oaModInstTerm\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModInstTerm)\n"
"    Calls: (const oaStringAppDef_oaModInstTerm&)\n"
"    Signature: oaStringAppDef_oaModInstTerm||cref-oaStringAppDef_oaModInstTerm,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModInstTerm_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModInstTerm",
    sizeof(PyoaStringAppDef_oaModInstTermObject),
    0,
    (destructor)oaStringAppDef_oaModInstTerm_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModInstTerm_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModInstTerm_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModInstTerm_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModInstTerm_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModInstTerm_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_static_find_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInstTerm* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInstTerm* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::find(p1.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInstTerm, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModInstTerm_static_get_doc[] = 
"Class: oaStringAppDef_oaModInstTerm, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModInstTerm_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModInstTermp result= (oaStringAppDef_oaModInstTerm::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModInstTerm_FromoaStringAppDef_oaModInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModInstTerm, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModInstTerm_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModInstTerm_static_find,METH_VARARGS,oaStringAppDef_oaModInstTerm_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModInstTerm_static_get,METH_VARARGS,oaStringAppDef_oaModInstTerm_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModInstTerm_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModInstTerm_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModInstTerm\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModInstTerm",
           (PyObject*)(&PyoaStringAppDef_oaModInstTerm_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModInstTerm\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModInstTerm_Type.tp_dict;
    for(method=oaStringAppDef_oaModInstTerm_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModModuleInstHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModModuleInstHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModModuleInstHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModModuleInstHeaderObject* self = (PyoaStringAppDef_oaModModuleInstHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModModuleInstHeader)
    {
        PyParamoaStringAppDef_oaModModuleInstHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModModuleInstHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModModuleInstHeader, Choices are:\n"
        "    (oaStringAppDef_oaModModuleInstHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModModuleInstHeader_tp_dealloc(PyoaStringAppDef_oaModModuleInstHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModModuleInstHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModModuleInstHeader value;
    int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[58];
    sprintf(buffer,"<oaStringAppDef_oaModModuleInstHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModModuleInstHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModModuleInstHeader v1;
    PyParamoaStringAppDef_oaModModuleInstHeader v2;
    int convert_status1=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModModuleInstHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaModModuleInstHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModModuleInstHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModModuleInstHeader**) ((PyoaStringAppDef_oaModModuleInstHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModModuleInstHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(oaStringAppDef_oaModModuleInstHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModModuleInstHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModModuleInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaModModuleInstHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModModuleInstHeaderObject* self = (PyoaStringAppDef_oaModModuleInstHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(oaStringAppDef_oaModModuleInstHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModModuleInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaModModuleInstHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModModuleInstHeaderObject* self = (PyoaStringAppDef_oaModModuleInstHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_get_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: get\n"
"  Paramegers: (oaModModuleInstHeader,oaString)\n"
"    Calls: void get(const oaModModuleInstHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModModuleInstHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModModuleInstHeaderObject* self=(PyoaStringAppDef_oaModModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModModuleInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModModuleInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModModuleInstHeaderObject* self=(PyoaStringAppDef_oaModModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_set_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: set\n"
"  Paramegers: (oaModModuleInstHeader,oaString)\n"
"    Calls: void set(oaModModuleInstHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModModuleInstHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModModuleInstHeaderObject* self=(PyoaStringAppDef_oaModModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModModuleInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModModuleInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_isNull_doc[] =
"Class: oaStringAppDef_oaModModuleInstHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModModuleInstHeader_assign_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModModuleInstHeader data;
  int convert_status=PyoaStringAppDef_oaModModuleInstHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModModuleInstHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModModuleInstHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModModuleInstHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_get,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_getDefault,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_set,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModModuleInstHeader)\n"
"    Calls: (const oaStringAppDef_oaModModuleInstHeader&)\n"
"    Signature: oaStringAppDef_oaModModuleInstHeader||cref-oaStringAppDef_oaModModuleInstHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModModuleInstHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModModuleInstHeader",
    sizeof(PyoaStringAppDef_oaModModuleInstHeaderObject),
    0,
    (destructor)oaStringAppDef_oaModModuleInstHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModModuleInstHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModModuleInstHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModModuleInstHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModModuleInstHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModModuleInstHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::find(p1.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModModuleInstHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModModuleInstHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaModModuleInstHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModModuleInstHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModModuleInstHeaderp result= (oaStringAppDef_oaModModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModModuleInstHeader_FromoaStringAppDef_oaModModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModModuleInstHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModModuleInstHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_static_find,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModModuleInstHeader_static_get,METH_VARARGS,oaStringAppDef_oaModModuleInstHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModModuleInstHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModModuleInstHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModModuleInstHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModModuleInstHeader",
           (PyObject*)(&PyoaStringAppDef_oaModModuleInstHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModModuleInstHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModModuleInstHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaModModuleInstHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModNet
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModNet_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModNet_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModNetObject* self = (PyoaStringAppDef_oaModNetObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModNet)
    {
        PyParamoaStringAppDef_oaModNet p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModNet_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModNet, Choices are:\n"
        "    (oaStringAppDef_oaModNet)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModNet_tp_dealloc(PyoaStringAppDef_oaModNetObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModNet_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModNet value;
    int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[45];
    sprintf(buffer,"<oaStringAppDef_oaModNet::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModNet_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModNet v1;
    PyParamoaStringAppDef_oaModNet v2;
    int convert_status1=PyoaStringAppDef_oaModNet_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModNet_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModNet_Convert(PyObject* ob,PyParamoaStringAppDef_oaModNet* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModNet_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModNet**) ((PyoaStringAppDef_oaModNetObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModNet Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(oaStringAppDef_oaModNet** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModNet* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModNet_Type.tp_alloc(&PyoaStringAppDef_oaModNet_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModNetObject* self = (PyoaStringAppDef_oaModNetObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(oaStringAppDef_oaModNet* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModNet_Type.tp_alloc(&PyoaStringAppDef_oaModNet_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModNetObject* self = (PyoaStringAppDef_oaModNetObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_get_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: get\n"
"  Paramegers: (oaModNet,oaString)\n"
"    Calls: void get(const oaModNet* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModNet,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModNet_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModNet data;
    int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModNetObject* self=(PyoaStringAppDef_oaModNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_getDefault_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModNet_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModNet data;
    int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModNetObject* self=(PyoaStringAppDef_oaModNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_set_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: set\n"
"  Paramegers: (oaModNet,oaString)\n"
"    Calls: void set(oaModNet* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModNet,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModNet_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModNet data;
    int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModNetObject* self=(PyoaStringAppDef_oaModNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_isNull_doc[] =
"Class: oaStringAppDef_oaModNet, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModNet_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModNet data;
    int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModNet_assign_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModNet_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModNet data;
  int convert_status=PyoaStringAppDef_oaModNet_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModNet p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModNet_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModNet_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModNet_get,METH_VARARGS,oaStringAppDef_oaModNet_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModNet_getDefault,METH_VARARGS,oaStringAppDef_oaModNet_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModNet_set,METH_VARARGS,oaStringAppDef_oaModNet_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModNet_tp_isNull,METH_VARARGS,oaStringAppDef_oaModNet_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModNet_tp_assign,METH_VARARGS,oaStringAppDef_oaModNet_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_doc[] = 
"Class: oaStringAppDef_oaModNet\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModNet)\n"
"    Calls: (const oaStringAppDef_oaModNet&)\n"
"    Signature: oaStringAppDef_oaModNet||cref-oaStringAppDef_oaModNet,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModNet_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModNet",
    sizeof(PyoaStringAppDef_oaModNetObject),
    0,
    (destructor)oaStringAppDef_oaModNet_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModNet_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModNet_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModNet_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModNet_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModNet_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_static_find_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModNet* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModNet|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModNet* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModNet|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModNet_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::find(p1.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModNet, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModNet_static_get_doc[] = 
"Class: oaStringAppDef_oaModNet, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModNet_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModNetp result= (oaStringAppDef_oaModNet::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModNet_FromoaStringAppDef_oaModNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModNet, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModNet_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModNet_static_find,METH_VARARGS,oaStringAppDef_oaModNet_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModNet_static_get,METH_VARARGS,oaStringAppDef_oaModNet_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModNet_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModNet_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModNet\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModNet",
           (PyObject*)(&PyoaStringAppDef_oaModNet_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModNet\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModNet_Type.tp_dict;
    for(method=oaStringAppDef_oaModNet_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModTerm
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModTerm_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModTerm_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModTermObject* self = (PyoaStringAppDef_oaModTermObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModTerm)
    {
        PyParamoaStringAppDef_oaModTerm p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModTerm_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModTerm, Choices are:\n"
        "    (oaStringAppDef_oaModTerm)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModTerm_tp_dealloc(PyoaStringAppDef_oaModTermObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModTerm_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModTerm value;
    int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[46];
    sprintf(buffer,"<oaStringAppDef_oaModTerm::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModTerm_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModTerm v1;
    PyParamoaStringAppDef_oaModTerm v2;
    int convert_status1=PyoaStringAppDef_oaModTerm_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModTerm_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModTerm_Convert(PyObject* ob,PyParamoaStringAppDef_oaModTerm* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModTerm_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModTerm**) ((PyoaStringAppDef_oaModTermObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModTerm Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(oaStringAppDef_oaModTerm** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModTerm* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModTerm_Type.tp_alloc(&PyoaStringAppDef_oaModTerm_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModTermObject* self = (PyoaStringAppDef_oaModTermObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(oaStringAppDef_oaModTerm* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModTerm_Type.tp_alloc(&PyoaStringAppDef_oaModTerm_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModTermObject* self = (PyoaStringAppDef_oaModTermObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_get_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: get\n"
"  Paramegers: (oaModTerm,oaString)\n"
"    Calls: void get(const oaModTerm* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModTerm,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModTerm_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModTerm data;
    int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModTermObject* self=(PyoaStringAppDef_oaModTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_getDefault_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModTerm_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModTerm data;
    int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModTermObject* self=(PyoaStringAppDef_oaModTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_set_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: set\n"
"  Paramegers: (oaModTerm,oaString)\n"
"    Calls: void set(oaModTerm* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModTerm,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModTerm_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModTerm data;
    int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModTermObject* self=(PyoaStringAppDef_oaModTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_isNull_doc[] =
"Class: oaStringAppDef_oaModTerm, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModTerm_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModTerm data;
    int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModTerm_assign_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModTerm_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModTerm data;
  int convert_status=PyoaStringAppDef_oaModTerm_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModTerm p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModTerm_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModTerm_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModTerm_get,METH_VARARGS,oaStringAppDef_oaModTerm_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModTerm_getDefault,METH_VARARGS,oaStringAppDef_oaModTerm_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModTerm_set,METH_VARARGS,oaStringAppDef_oaModTerm_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModTerm_tp_isNull,METH_VARARGS,oaStringAppDef_oaModTerm_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModTerm_tp_assign,METH_VARARGS,oaStringAppDef_oaModTerm_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_doc[] = 
"Class: oaStringAppDef_oaModTerm\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModTerm)\n"
"    Calls: (const oaStringAppDef_oaModTerm&)\n"
"    Signature: oaStringAppDef_oaModTerm||cref-oaStringAppDef_oaModTerm,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModTerm_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModTerm",
    sizeof(PyoaStringAppDef_oaModTermObject),
    0,
    (destructor)oaStringAppDef_oaModTerm_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModTerm_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModTerm_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModTerm_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModTerm_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModTerm_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_static_find_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModTerm* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModTerm|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModTerm* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModTerm|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModTerm_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::find(p1.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModTerm, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModTerm_static_get_doc[] = 
"Class: oaStringAppDef_oaModTerm, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModTerm_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModTermp result= (oaStringAppDef_oaModTerm::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModTerm_FromoaStringAppDef_oaModTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModTerm, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModTerm_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModTerm_static_find,METH_VARARGS,oaStringAppDef_oaModTerm_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModTerm_static_get,METH_VARARGS,oaStringAppDef_oaModTerm_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModTerm_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModTerm_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModTerm\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModTerm",
           (PyObject*)(&PyoaStringAppDef_oaModTerm_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModTerm\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModTerm_Type.tp_dict;
    for(method=oaStringAppDef_oaModTerm_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModVectorInstDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModVectorInstDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModVectorInstDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModVectorInstDefObject* self = (PyoaStringAppDef_oaModVectorInstDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModVectorInstDef)
    {
        PyParamoaStringAppDef_oaModVectorInstDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModVectorInstDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModVectorInstDef, Choices are:\n"
        "    (oaStringAppDef_oaModVectorInstDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModVectorInstDef_tp_dealloc(PyoaStringAppDef_oaModVectorInstDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModVectorInstDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModVectorInstDef value;
    int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[55];
    sprintf(buffer,"<oaStringAppDef_oaModVectorInstDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModVectorInstDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModVectorInstDef v1;
    PyParamoaStringAppDef_oaModVectorInstDef v2;
    int convert_status1=PyoaStringAppDef_oaModVectorInstDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModVectorInstDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModVectorInstDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaModVectorInstDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModVectorInstDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModVectorInstDef**) ((PyoaStringAppDef_oaModVectorInstDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModVectorInstDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(oaStringAppDef_oaModVectorInstDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModVectorInstDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModVectorInstDef_Type.tp_alloc(&PyoaStringAppDef_oaModVectorInstDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModVectorInstDefObject* self = (PyoaStringAppDef_oaModVectorInstDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(oaStringAppDef_oaModVectorInstDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModVectorInstDef_Type.tp_alloc(&PyoaStringAppDef_oaModVectorInstDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModVectorInstDefObject* self = (PyoaStringAppDef_oaModVectorInstDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_get_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: get\n"
"  Paramegers: (oaModVectorInstDef,oaString)\n"
"    Calls: void get(const oaModVectorInstDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModVectorInstDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModVectorInstDefObject* self=(PyoaStringAppDef_oaModVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModVectorInstDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModVectorInstDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModVectorInstDefObject* self=(PyoaStringAppDef_oaModVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_set_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: set\n"
"  Paramegers: (oaModVectorInstDef,oaString)\n"
"    Calls: void set(oaModVectorInstDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModVectorInstDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModVectorInstDefObject* self=(PyoaStringAppDef_oaModVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModVectorInstDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModVectorInstDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_isNull_doc[] =
"Class: oaStringAppDef_oaModVectorInstDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModVectorInstDef_assign_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModVectorInstDef data;
  int convert_status=PyoaStringAppDef_oaModVectorInstDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModVectorInstDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModVectorInstDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModVectorInstDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModVectorInstDef_get,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModVectorInstDef_getDefault,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModVectorInstDef_set,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModVectorInstDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModVectorInstDef_tp_assign,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModVectorInstDef)\n"
"    Calls: (const oaStringAppDef_oaModVectorInstDef&)\n"
"    Signature: oaStringAppDef_oaModVectorInstDef||cref-oaStringAppDef_oaModVectorInstDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModVectorInstDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModVectorInstDef",
    sizeof(PyoaStringAppDef_oaModVectorInstDefObject),
    0,
    (destructor)oaStringAppDef_oaModVectorInstDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModVectorInstDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModVectorInstDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModVectorInstDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModVectorInstDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModVectorInstDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_static_find_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::find(p1.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModVectorInstDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModVectorInstDef_static_get_doc[] = 
"Class: oaStringAppDef_oaModVectorInstDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModVectorInstDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModVectorInstDefp result= (oaStringAppDef_oaModVectorInstDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModVectorInstDef_FromoaStringAppDef_oaModVectorInstDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModVectorInstDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModVectorInstDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModVectorInstDef_static_find,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModVectorInstDef_static_get,METH_VARARGS,oaStringAppDef_oaModVectorInstDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModVectorInstDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModVectorInstDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModVectorInstDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModVectorInstDef",
           (PyObject*)(&PyoaStringAppDef_oaModVectorInstDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModVectorInstDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModVectorInstDef_Type.tp_dict;
    for(method=oaStringAppDef_oaModVectorInstDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaModule
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModule_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaModule_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaModuleObject* self = (PyoaStringAppDef_oaModuleObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaModule)
    {
        PyParamoaStringAppDef_oaModule p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaModule_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaModule, Choices are:\n"
        "    (oaStringAppDef_oaModule)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaModule_tp_dealloc(PyoaStringAppDef_oaModuleObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaModule_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaModule value;
    int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[45];
    sprintf(buffer,"<oaStringAppDef_oaModule::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaModule_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaModule v1;
    PyParamoaStringAppDef_oaModule v2;
    int convert_status1=PyoaStringAppDef_oaModule_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaModule_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaModule_Convert(PyObject* ob,PyParamoaStringAppDef_oaModule* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaModule_Check(ob)) {
        result->SetData( (oaStringAppDef_oaModule**) ((PyoaStringAppDef_oaModuleObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaModule Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(oaStringAppDef_oaModule** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaModule* data=*value;
        PyObject* bself = PyoaStringAppDef_oaModule_Type.tp_alloc(&PyoaStringAppDef_oaModule_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaModuleObject* self = (PyoaStringAppDef_oaModuleObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(oaStringAppDef_oaModule* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaModule_Type.tp_alloc(&PyoaStringAppDef_oaModule_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaModuleObject* self = (PyoaStringAppDef_oaModuleObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_get_doc[] = 
"Class: oaStringAppDef_oaModule, Function: get\n"
"  Paramegers: (oaModule,oaString)\n"
"    Calls: void get(const oaModule* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaModule,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModule_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModule data;
    int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModuleObject* self=(PyoaStringAppDef_oaModuleObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModule p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModule_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_getDefault_doc[] = 
"Class: oaStringAppDef_oaModule, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaModule_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModule data;
    int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModuleObject* self=(PyoaStringAppDef_oaModuleObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_set_doc[] = 
"Class: oaStringAppDef_oaModule, Function: set\n"
"  Paramegers: (oaModule,oaString)\n"
"    Calls: void set(oaModule* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaModule,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaModule_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaModule data;
    int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaModuleObject* self=(PyoaStringAppDef_oaModuleObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaModule p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaModule_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_isNull_doc[] =
"Class: oaStringAppDef_oaModule, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaModule_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaModule data;
    int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaModule_assign_doc[] = 
"Class: oaStringAppDef_oaModule, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaModule_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaModule data;
  int convert_status=PyoaStringAppDef_oaModule_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaModule p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaModule_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaModule_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaModule_get,METH_VARARGS,oaStringAppDef_oaModule_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaModule_getDefault,METH_VARARGS,oaStringAppDef_oaModule_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaModule_set,METH_VARARGS,oaStringAppDef_oaModule_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaModule_tp_isNull,METH_VARARGS,oaStringAppDef_oaModule_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaModule_tp_assign,METH_VARARGS,oaStringAppDef_oaModule_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_doc[] = 
"Class: oaStringAppDef_oaModule\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaModule)\n"
"    Calls: (const oaStringAppDef_oaModule&)\n"
"    Signature: oaStringAppDef_oaModule||cref-oaStringAppDef_oaModule,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaModule_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaModule",
    sizeof(PyoaStringAppDef_oaModuleObject),
    0,
    (destructor)oaStringAppDef_oaModule_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaModule_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaModule_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaModule_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaModule_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaModule_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_static_find_doc[] = 
"Class: oaStringAppDef_oaModule, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModule* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaModule|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModule* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaModule|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaModule_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::find(p1.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModule, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaModule_static_get_doc[] = 
"Class: oaStringAppDef_oaModule, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaModule* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaModule|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaModule_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaModulep result= (oaStringAppDef_oaModule::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaModule_FromoaStringAppDef_oaModule(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaModule, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaModule_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaModule_static_find,METH_VARARGS,oaStringAppDef_oaModule_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaModule_static_get,METH_VARARGS,oaStringAppDef_oaModule_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaModule_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaModule_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaModule\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaModule",
           (PyObject*)(&PyoaStringAppDef_oaModule_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaModule\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaModule_Type.tp_dict;
    for(method=oaStringAppDef_oaModule_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaNet
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaNet_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaNet_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaNetObject* self = (PyoaStringAppDef_oaNetObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaNet)
    {
        PyParamoaStringAppDef_oaNet p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaNet_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaNet, Choices are:\n"
        "    (oaStringAppDef_oaNet)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaNet_tp_dealloc(PyoaStringAppDef_oaNetObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaNet_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaNet value;
    int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[42];
    sprintf(buffer,"<oaStringAppDef_oaNet::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaNet_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaNet v1;
    PyParamoaStringAppDef_oaNet v2;
    int convert_status1=PyoaStringAppDef_oaNet_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaNet_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaNet_Convert(PyObject* ob,PyParamoaStringAppDef_oaNet* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaNet_Check(ob)) {
        result->SetData( (oaStringAppDef_oaNet**) ((PyoaStringAppDef_oaNetObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaNet Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(oaStringAppDef_oaNet** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaNet* data=*value;
        PyObject* bself = PyoaStringAppDef_oaNet_Type.tp_alloc(&PyoaStringAppDef_oaNet_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaNetObject* self = (PyoaStringAppDef_oaNetObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(oaStringAppDef_oaNet* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaNet_Type.tp_alloc(&PyoaStringAppDef_oaNet_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaNetObject* self = (PyoaStringAppDef_oaNetObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_get_doc[] = 
"Class: oaStringAppDef_oaNet, Function: get\n"
"  Paramegers: (oaNet,oaString)\n"
"    Calls: void get(const oaNet* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaNet,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaNet_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNet data;
    int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNetObject* self=(PyoaStringAppDef_oaNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_getDefault_doc[] = 
"Class: oaStringAppDef_oaNet, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaNet_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNet data;
    int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNetObject* self=(PyoaStringAppDef_oaNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_set_doc[] = 
"Class: oaStringAppDef_oaNet, Function: set\n"
"  Paramegers: (oaNet,oaString)\n"
"    Calls: void set(oaNet* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaNet,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaNet_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNet data;
    int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNetObject* self=(PyoaStringAppDef_oaNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_isNull_doc[] =
"Class: oaStringAppDef_oaNet, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaNet_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaNet data;
    int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaNet_assign_doc[] = 
"Class: oaStringAppDef_oaNet, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaNet_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaNet data;
  int convert_status=PyoaStringAppDef_oaNet_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaNet p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaNet_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaNet_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaNet_get,METH_VARARGS,oaStringAppDef_oaNet_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaNet_getDefault,METH_VARARGS,oaStringAppDef_oaNet_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaNet_set,METH_VARARGS,oaStringAppDef_oaNet_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaNet_tp_isNull,METH_VARARGS,oaStringAppDef_oaNet_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaNet_tp_assign,METH_VARARGS,oaStringAppDef_oaNet_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_doc[] = 
"Class: oaStringAppDef_oaNet\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaNet)\n"
"    Calls: (const oaStringAppDef_oaNet&)\n"
"    Signature: oaStringAppDef_oaNet||cref-oaStringAppDef_oaNet,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaNet_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaNet",
    sizeof(PyoaStringAppDef_oaNetObject),
    0,
    (destructor)oaStringAppDef_oaNet_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaNet_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaNet_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaNet_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaNet_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaNet_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_static_find_doc[] = 
"Class: oaStringAppDef_oaNet, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaNet* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaNet|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaNet* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaNet|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaNet_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::find(p1.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaNet, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNet_static_get_doc[] = 
"Class: oaStringAppDef_oaNet, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaNet_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNetp result= (oaStringAppDef_oaNet::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaNet_FromoaStringAppDef_oaNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaNet, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaNet_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaNet_static_find,METH_VARARGS,oaStringAppDef_oaNet_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaNet_static_get,METH_VARARGS,oaStringAppDef_oaNet_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaNet_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaNet_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaNet\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaNet",
           (PyObject*)(&PyoaStringAppDef_oaNet_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaNet\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaNet_Type.tp_dict;
    for(method=oaStringAppDef_oaNet_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaNode
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaNode_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaNode_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaNodeObject* self = (PyoaStringAppDef_oaNodeObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaNode)
    {
        PyParamoaStringAppDef_oaNode p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaNode_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaNode, Choices are:\n"
        "    (oaStringAppDef_oaNode)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaNode_tp_dealloc(PyoaStringAppDef_oaNodeObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaNode_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaNode value;
    int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[43];
    sprintf(buffer,"<oaStringAppDef_oaNode::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaNode_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaNode v1;
    PyParamoaStringAppDef_oaNode v2;
    int convert_status1=PyoaStringAppDef_oaNode_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaNode_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaNode_Convert(PyObject* ob,PyParamoaStringAppDef_oaNode* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaNode_Check(ob)) {
        result->SetData( (oaStringAppDef_oaNode**) ((PyoaStringAppDef_oaNodeObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaNode Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(oaStringAppDef_oaNode** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaNode* data=*value;
        PyObject* bself = PyoaStringAppDef_oaNode_Type.tp_alloc(&PyoaStringAppDef_oaNode_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaNodeObject* self = (PyoaStringAppDef_oaNodeObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(oaStringAppDef_oaNode* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaNode_Type.tp_alloc(&PyoaStringAppDef_oaNode_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaNodeObject* self = (PyoaStringAppDef_oaNodeObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_get_doc[] = 
"Class: oaStringAppDef_oaNode, Function: get\n"
"  Paramegers: (oaNode,oaString)\n"
"    Calls: void get(const oaNode* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaNode,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaNode_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNode data;
    int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNodeObject* self=(PyoaStringAppDef_oaNodeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaNode p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaNode_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_getDefault_doc[] = 
"Class: oaStringAppDef_oaNode, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaNode_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNode data;
    int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNodeObject* self=(PyoaStringAppDef_oaNodeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_set_doc[] = 
"Class: oaStringAppDef_oaNode, Function: set\n"
"  Paramegers: (oaNode,oaString)\n"
"    Calls: void set(oaNode* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaNode,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaNode_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaNode data;
    int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaNodeObject* self=(PyoaStringAppDef_oaNodeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaNode p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaNode_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_isNull_doc[] =
"Class: oaStringAppDef_oaNode, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaNode_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaNode data;
    int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaNode_assign_doc[] = 
"Class: oaStringAppDef_oaNode, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaNode_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaNode data;
  int convert_status=PyoaStringAppDef_oaNode_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaNode p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaNode_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaNode_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaNode_get,METH_VARARGS,oaStringAppDef_oaNode_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaNode_getDefault,METH_VARARGS,oaStringAppDef_oaNode_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaNode_set,METH_VARARGS,oaStringAppDef_oaNode_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaNode_tp_isNull,METH_VARARGS,oaStringAppDef_oaNode_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaNode_tp_assign,METH_VARARGS,oaStringAppDef_oaNode_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_doc[] = 
"Class: oaStringAppDef_oaNode\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaNode)\n"
"    Calls: (const oaStringAppDef_oaNode&)\n"
"    Signature: oaStringAppDef_oaNode||cref-oaStringAppDef_oaNode,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaNode_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaNode",
    sizeof(PyoaStringAppDef_oaNodeObject),
    0,
    (destructor)oaStringAppDef_oaNode_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaNode_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaNode_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaNode_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaNode_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaNode_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_static_find_doc[] = 
"Class: oaStringAppDef_oaNode, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaNode* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaNode|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaNode* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaNode|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaNode_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::find(p1.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaNode, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaNode_static_get_doc[] = 
"Class: oaStringAppDef_oaNode, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaNode* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaNode|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaNode_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaNodep result= (oaStringAppDef_oaNode::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaNode_FromoaStringAppDef_oaNode(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaNode, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaNode_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaNode_static_find,METH_VARARGS,oaStringAppDef_oaNode_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaNode_static_get,METH_VARARGS,oaStringAppDef_oaNode_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaNode_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaNode_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaNode\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaNode",
           (PyObject*)(&PyoaStringAppDef_oaNode_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaNode\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaNode_Type.tp_dict;
    for(method=oaStringAppDef_oaNode_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccAssignment
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccAssignment_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccAssignment_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccAssignmentObject* self = (PyoaStringAppDef_oaOccAssignmentObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccAssignment)
    {
        PyParamoaStringAppDef_oaOccAssignment p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccAssignment_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccAssignment, Choices are:\n"
        "    (oaStringAppDef_oaOccAssignment)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccAssignment_tp_dealloc(PyoaStringAppDef_oaOccAssignmentObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccAssignment_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccAssignment value;
    int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaOccAssignment::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccAssignment_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccAssignment v1;
    PyParamoaStringAppDef_oaOccAssignment v2;
    int convert_status1=PyoaStringAppDef_oaOccAssignment_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccAssignment_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccAssignment_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccAssignment* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccAssignment_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccAssignment**) ((PyoaStringAppDef_oaOccAssignmentObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccAssignment Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(oaStringAppDef_oaOccAssignment** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccAssignment* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccAssignment_Type.tp_alloc(&PyoaStringAppDef_oaOccAssignment_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccAssignmentObject* self = (PyoaStringAppDef_oaOccAssignmentObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(oaStringAppDef_oaOccAssignment* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccAssignment_Type.tp_alloc(&PyoaStringAppDef_oaOccAssignment_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccAssignmentObject* self = (PyoaStringAppDef_oaOccAssignmentObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_get_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: get\n"
"  Paramegers: (oaOccAssignment,oaString)\n"
"    Calls: void get(const oaOccAssignment* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccAssignment,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccAssignment data;
    int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccAssignmentObject* self=(PyoaStringAppDef_oaOccAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccAssignment p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccAssignment_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccAssignment data;
    int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccAssignmentObject* self=(PyoaStringAppDef_oaOccAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_set_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: set\n"
"  Paramegers: (oaOccAssignment,oaString)\n"
"    Calls: void set(oaOccAssignment* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccAssignment,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccAssignment data;
    int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccAssignmentObject* self=(PyoaStringAppDef_oaOccAssignmentObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccAssignment p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccAssignment_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_isNull_doc[] =
"Class: oaStringAppDef_oaOccAssignment, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccAssignment data;
    int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccAssignment_assign_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccAssignment data;
  int convert_status=PyoaStringAppDef_oaOccAssignment_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccAssignment p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccAssignment_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccAssignment_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccAssignment_get,METH_VARARGS,oaStringAppDef_oaOccAssignment_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccAssignment_getDefault,METH_VARARGS,oaStringAppDef_oaOccAssignment_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccAssignment_set,METH_VARARGS,oaStringAppDef_oaOccAssignment_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccAssignment_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccAssignment_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccAssignment_tp_assign,METH_VARARGS,oaStringAppDef_oaOccAssignment_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_doc[] = 
"Class: oaStringAppDef_oaOccAssignment\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccAssignment)\n"
"    Calls: (const oaStringAppDef_oaOccAssignment&)\n"
"    Signature: oaStringAppDef_oaOccAssignment||cref-oaStringAppDef_oaOccAssignment,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccAssignment_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccAssignment",
    sizeof(PyoaStringAppDef_oaOccAssignmentObject),
    0,
    (destructor)oaStringAppDef_oaOccAssignment_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccAssignment_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccAssignment_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccAssignment_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccAssignment_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccAssignment_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_static_find_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccAssignment* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccAssignment* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::find(p1.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccAssignment, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccAssignment_static_get_doc[] = 
"Class: oaStringAppDef_oaOccAssignment, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccAssignment* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccAssignment|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccAssignment_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccAssignmentp result= (oaStringAppDef_oaOccAssignment::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccAssignment_FromoaStringAppDef_oaOccAssignment(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccAssignment, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccAssignment_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccAssignment_static_find,METH_VARARGS,oaStringAppDef_oaOccAssignment_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccAssignment_static_get,METH_VARARGS,oaStringAppDef_oaOccAssignment_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccAssignment_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccAssignment_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccAssignment\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccAssignment",
           (PyObject*)(&PyoaStringAppDef_oaOccAssignment_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccAssignment\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccAssignment_Type.tp_dict;
    for(method=oaStringAppDef_oaOccAssignment_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccBusNetDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccBusNetDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccBusNetDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccBusNetDefObject* self = (PyoaStringAppDef_oaOccBusNetDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccBusNetDef)
    {
        PyParamoaStringAppDef_oaOccBusNetDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccBusNetDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccBusNetDef, Choices are:\n"
        "    (oaStringAppDef_oaOccBusNetDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccBusNetDef_tp_dealloc(PyoaStringAppDef_oaOccBusNetDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccBusNetDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccBusNetDef value;
    int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[51];
    sprintf(buffer,"<oaStringAppDef_oaOccBusNetDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccBusNetDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccBusNetDef v1;
    PyParamoaStringAppDef_oaOccBusNetDef v2;
    int convert_status1=PyoaStringAppDef_oaOccBusNetDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccBusNetDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccBusNetDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccBusNetDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccBusNetDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccBusNetDef**) ((PyoaStringAppDef_oaOccBusNetDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccBusNetDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(oaStringAppDef_oaOccBusNetDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccBusNetDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccBusNetDef_Type.tp_alloc(&PyoaStringAppDef_oaOccBusNetDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccBusNetDefObject* self = (PyoaStringAppDef_oaOccBusNetDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(oaStringAppDef_oaOccBusNetDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccBusNetDef_Type.tp_alloc(&PyoaStringAppDef_oaOccBusNetDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccBusNetDefObject* self = (PyoaStringAppDef_oaOccBusNetDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_get_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: get\n"
"  Paramegers: (oaOccBusNetDef,oaString)\n"
"    Calls: void get(const oaOccBusNetDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccBusNetDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusNetDef data;
    int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusNetDefObject* self=(PyoaStringAppDef_oaOccBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccBusNetDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccBusNetDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusNetDef data;
    int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusNetDefObject* self=(PyoaStringAppDef_oaOccBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_set_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: set\n"
"  Paramegers: (oaOccBusNetDef,oaString)\n"
"    Calls: void set(oaOccBusNetDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccBusNetDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusNetDef data;
    int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusNetDefObject* self=(PyoaStringAppDef_oaOccBusNetDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccBusNetDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccBusNetDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_isNull_doc[] =
"Class: oaStringAppDef_oaOccBusNetDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccBusNetDef data;
    int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccBusNetDef_assign_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccBusNetDef data;
  int convert_status=PyoaStringAppDef_oaOccBusNetDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccBusNetDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccBusNetDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccBusNetDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccBusNetDef_get,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccBusNetDef_getDefault,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccBusNetDef_set,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccBusNetDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccBusNetDef_tp_assign,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccBusNetDef)\n"
"    Calls: (const oaStringAppDef_oaOccBusNetDef&)\n"
"    Signature: oaStringAppDef_oaOccBusNetDef||cref-oaStringAppDef_oaOccBusNetDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccBusNetDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccBusNetDef",
    sizeof(PyoaStringAppDef_oaOccBusNetDefObject),
    0,
    (destructor)oaStringAppDef_oaOccBusNetDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccBusNetDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccBusNetDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccBusNetDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccBusNetDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccBusNetDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_static_find_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::find(p1.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccBusNetDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusNetDef_static_get_doc[] = 
"Class: oaStringAppDef_oaOccBusNetDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccBusNetDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusNetDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccBusNetDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusNetDefp result= (oaStringAppDef_oaOccBusNetDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccBusNetDef_FromoaStringAppDef_oaOccBusNetDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccBusNetDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccBusNetDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccBusNetDef_static_find,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccBusNetDef_static_get,METH_VARARGS,oaStringAppDef_oaOccBusNetDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccBusNetDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccBusNetDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccBusNetDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccBusNetDef",
           (PyObject*)(&PyoaStringAppDef_oaOccBusNetDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccBusNetDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccBusNetDef_Type.tp_dict;
    for(method=oaStringAppDef_oaOccBusNetDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccBusTermDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccBusTermDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccBusTermDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccBusTermDefObject* self = (PyoaStringAppDef_oaOccBusTermDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccBusTermDef)
    {
        PyParamoaStringAppDef_oaOccBusTermDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccBusTermDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccBusTermDef, Choices are:\n"
        "    (oaStringAppDef_oaOccBusTermDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccBusTermDef_tp_dealloc(PyoaStringAppDef_oaOccBusTermDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccBusTermDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccBusTermDef value;
    int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaOccBusTermDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccBusTermDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccBusTermDef v1;
    PyParamoaStringAppDef_oaOccBusTermDef v2;
    int convert_status1=PyoaStringAppDef_oaOccBusTermDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccBusTermDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccBusTermDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccBusTermDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccBusTermDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccBusTermDef**) ((PyoaStringAppDef_oaOccBusTermDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccBusTermDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(oaStringAppDef_oaOccBusTermDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccBusTermDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccBusTermDef_Type.tp_alloc(&PyoaStringAppDef_oaOccBusTermDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccBusTermDefObject* self = (PyoaStringAppDef_oaOccBusTermDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(oaStringAppDef_oaOccBusTermDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccBusTermDef_Type.tp_alloc(&PyoaStringAppDef_oaOccBusTermDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccBusTermDefObject* self = (PyoaStringAppDef_oaOccBusTermDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_get_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: get\n"
"  Paramegers: (oaOccBusTermDef,oaString)\n"
"    Calls: void get(const oaOccBusTermDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccBusTermDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusTermDef data;
    int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusTermDefObject* self=(PyoaStringAppDef_oaOccBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccBusTermDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccBusTermDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusTermDef data;
    int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusTermDefObject* self=(PyoaStringAppDef_oaOccBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_set_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: set\n"
"  Paramegers: (oaOccBusTermDef,oaString)\n"
"    Calls: void set(oaOccBusTermDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccBusTermDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccBusTermDef data;
    int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccBusTermDefObject* self=(PyoaStringAppDef_oaOccBusTermDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccBusTermDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccBusTermDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_isNull_doc[] =
"Class: oaStringAppDef_oaOccBusTermDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccBusTermDef data;
    int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccBusTermDef_assign_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccBusTermDef data;
  int convert_status=PyoaStringAppDef_oaOccBusTermDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccBusTermDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccBusTermDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccBusTermDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccBusTermDef_get,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccBusTermDef_getDefault,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccBusTermDef_set,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccBusTermDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccBusTermDef_tp_assign,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccBusTermDef)\n"
"    Calls: (const oaStringAppDef_oaOccBusTermDef&)\n"
"    Signature: oaStringAppDef_oaOccBusTermDef||cref-oaStringAppDef_oaOccBusTermDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccBusTermDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccBusTermDef",
    sizeof(PyoaStringAppDef_oaOccBusTermDefObject),
    0,
    (destructor)oaStringAppDef_oaOccBusTermDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccBusTermDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccBusTermDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccBusTermDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccBusTermDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccBusTermDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_static_find_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::find(p1.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccBusTermDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccBusTermDef_static_get_doc[] = 
"Class: oaStringAppDef_oaOccBusTermDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccBusTermDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccBusTermDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccBusTermDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccBusTermDefp result= (oaStringAppDef_oaOccBusTermDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccBusTermDef_FromoaStringAppDef_oaOccBusTermDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccBusTermDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccBusTermDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccBusTermDef_static_find,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccBusTermDef_static_get,METH_VARARGS,oaStringAppDef_oaOccBusTermDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccBusTermDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccBusTermDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccBusTermDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccBusTermDef",
           (PyObject*)(&PyoaStringAppDef_oaOccBusTermDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccBusTermDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccBusTermDef_Type.tp_dict;
    for(method=oaStringAppDef_oaOccBusTermDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccConnectDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccConnectDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccConnectDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccConnectDefObject* self = (PyoaStringAppDef_oaOccConnectDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccConnectDef)
    {
        PyParamoaStringAppDef_oaOccConnectDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccConnectDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccConnectDef, Choices are:\n"
        "    (oaStringAppDef_oaOccConnectDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccConnectDef_tp_dealloc(PyoaStringAppDef_oaOccConnectDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccConnectDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccConnectDef value;
    int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaOccConnectDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccConnectDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccConnectDef v1;
    PyParamoaStringAppDef_oaOccConnectDef v2;
    int convert_status1=PyoaStringAppDef_oaOccConnectDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccConnectDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccConnectDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccConnectDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccConnectDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccConnectDef**) ((PyoaStringAppDef_oaOccConnectDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccConnectDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(oaStringAppDef_oaOccConnectDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccConnectDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccConnectDef_Type.tp_alloc(&PyoaStringAppDef_oaOccConnectDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccConnectDefObject* self = (PyoaStringAppDef_oaOccConnectDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(oaStringAppDef_oaOccConnectDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccConnectDef_Type.tp_alloc(&PyoaStringAppDef_oaOccConnectDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccConnectDefObject* self = (PyoaStringAppDef_oaOccConnectDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_get_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: get\n"
"  Paramegers: (oaOccConnectDef,oaString)\n"
"    Calls: void get(const oaOccConnectDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccConnectDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccConnectDef data;
    int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccConnectDefObject* self=(PyoaStringAppDef_oaOccConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccConnectDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccConnectDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccConnectDef data;
    int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccConnectDefObject* self=(PyoaStringAppDef_oaOccConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_set_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: set\n"
"  Paramegers: (oaOccConnectDef,oaString)\n"
"    Calls: void set(oaOccConnectDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccConnectDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccConnectDef data;
    int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccConnectDefObject* self=(PyoaStringAppDef_oaOccConnectDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccConnectDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccConnectDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_isNull_doc[] =
"Class: oaStringAppDef_oaOccConnectDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccConnectDef data;
    int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccConnectDef_assign_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccConnectDef data;
  int convert_status=PyoaStringAppDef_oaOccConnectDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccConnectDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccConnectDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccConnectDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccConnectDef_get,METH_VARARGS,oaStringAppDef_oaOccConnectDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccConnectDef_getDefault,METH_VARARGS,oaStringAppDef_oaOccConnectDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccConnectDef_set,METH_VARARGS,oaStringAppDef_oaOccConnectDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccConnectDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccConnectDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccConnectDef_tp_assign,METH_VARARGS,oaStringAppDef_oaOccConnectDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccConnectDef)\n"
"    Calls: (const oaStringAppDef_oaOccConnectDef&)\n"
"    Signature: oaStringAppDef_oaOccConnectDef||cref-oaStringAppDef_oaOccConnectDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccConnectDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccConnectDef",
    sizeof(PyoaStringAppDef_oaOccConnectDefObject),
    0,
    (destructor)oaStringAppDef_oaOccConnectDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccConnectDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccConnectDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccConnectDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccConnectDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccConnectDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_static_find_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::find(p1.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccConnectDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccConnectDef_static_get_doc[] = 
"Class: oaStringAppDef_oaOccConnectDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccConnectDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccConnectDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccConnectDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccConnectDefp result= (oaStringAppDef_oaOccConnectDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccConnectDef_FromoaStringAppDef_oaOccConnectDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccConnectDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccConnectDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccConnectDef_static_find,METH_VARARGS,oaStringAppDef_oaOccConnectDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccConnectDef_static_get,METH_VARARGS,oaStringAppDef_oaOccConnectDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccConnectDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccConnectDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccConnectDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccConnectDef",
           (PyObject*)(&PyoaStringAppDef_oaOccConnectDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccConnectDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccConnectDef_Type.tp_dict;
    for(method=oaStringAppDef_oaOccConnectDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccInst
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInst_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccInst_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccInstObject* self = (PyoaStringAppDef_oaOccInstObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccInst)
    {
        PyParamoaStringAppDef_oaOccInst p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccInst_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccInst, Choices are:\n"
        "    (oaStringAppDef_oaOccInst)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccInst_tp_dealloc(PyoaStringAppDef_oaOccInstObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInst_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccInst value;
    int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[46];
    sprintf(buffer,"<oaStringAppDef_oaOccInst::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccInst_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccInst v1;
    PyParamoaStringAppDef_oaOccInst v2;
    int convert_status1=PyoaStringAppDef_oaOccInst_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccInst_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccInst_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccInst* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccInst_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccInst**) ((PyoaStringAppDef_oaOccInstObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccInst Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(oaStringAppDef_oaOccInst** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccInst* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccInst_Type.tp_alloc(&PyoaStringAppDef_oaOccInst_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccInstObject* self = (PyoaStringAppDef_oaOccInstObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(oaStringAppDef_oaOccInst* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccInst_Type.tp_alloc(&PyoaStringAppDef_oaOccInst_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccInstObject* self = (PyoaStringAppDef_oaOccInstObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_get_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: get\n"
"  Paramegers: (oaOccInst,oaString)\n"
"    Calls: void get(const oaOccInst* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccInst,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInst_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInst data;
    int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstObject* self=(PyoaStringAppDef_oaOccInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccInst_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInst data;
    int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstObject* self=(PyoaStringAppDef_oaOccInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_set_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: set\n"
"  Paramegers: (oaOccInst,oaString)\n"
"    Calls: void set(oaOccInst* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccInst,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInst_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInst data;
    int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstObject* self=(PyoaStringAppDef_oaOccInstObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInst p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInst_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_isNull_doc[] =
"Class: oaStringAppDef_oaOccInst, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccInst_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccInst data;
    int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccInst_assign_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccInst_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccInst data;
  int convert_status=PyoaStringAppDef_oaOccInst_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccInst p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccInst_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccInst_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccInst_get,METH_VARARGS,oaStringAppDef_oaOccInst_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccInst_getDefault,METH_VARARGS,oaStringAppDef_oaOccInst_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccInst_set,METH_VARARGS,oaStringAppDef_oaOccInst_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccInst_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccInst_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccInst_tp_assign,METH_VARARGS,oaStringAppDef_oaOccInst_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_doc[] = 
"Class: oaStringAppDef_oaOccInst\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccInst)\n"
"    Calls: (const oaStringAppDef_oaOccInst&)\n"
"    Signature: oaStringAppDef_oaOccInst||cref-oaStringAppDef_oaOccInst,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccInst_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccInst",
    sizeof(PyoaStringAppDef_oaOccInstObject),
    0,
    (destructor)oaStringAppDef_oaOccInst_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccInst_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccInst_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccInst_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccInst_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccInst_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_static_find_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInst* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInst|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInst* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInst|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccInst_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::find(p1.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInst, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInst_static_get_doc[] = 
"Class: oaStringAppDef_oaOccInst, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInst* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInst|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccInst_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstp result= (oaStringAppDef_oaOccInst::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccInst_FromoaStringAppDef_oaOccInst(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInst, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccInst_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccInst_static_find,METH_VARARGS,oaStringAppDef_oaOccInst_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccInst_static_get,METH_VARARGS,oaStringAppDef_oaOccInst_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccInst_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccInst_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccInst\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccInst",
           (PyObject*)(&PyoaStringAppDef_oaOccInst_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccInst\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccInst_Type.tp_dict;
    for(method=oaStringAppDef_oaOccInst_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccInstHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInstHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccInstHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccInstHeaderObject* self = (PyoaStringAppDef_oaOccInstHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccInstHeader)
    {
        PyParamoaStringAppDef_oaOccInstHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccInstHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccInstHeader, Choices are:\n"
        "    (oaStringAppDef_oaOccInstHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccInstHeader_tp_dealloc(PyoaStringAppDef_oaOccInstHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInstHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccInstHeader value;
    int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaOccInstHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccInstHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccInstHeader v1;
    PyParamoaStringAppDef_oaOccInstHeader v2;
    int convert_status1=PyoaStringAppDef_oaOccInstHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccInstHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccInstHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccInstHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccInstHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccInstHeader**) ((PyoaStringAppDef_oaOccInstHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccInstHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(oaStringAppDef_oaOccInstHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccInstHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaOccInstHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccInstHeaderObject* self = (PyoaStringAppDef_oaOccInstHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(oaStringAppDef_oaOccInstHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaOccInstHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccInstHeaderObject* self = (PyoaStringAppDef_oaOccInstHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_get_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: get\n"
"  Paramegers: (oaOccInstHeader,oaString)\n"
"    Calls: void get(const oaOccInstHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccInstHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstHeaderObject* self=(PyoaStringAppDef_oaOccInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstHeaderObject* self=(PyoaStringAppDef_oaOccInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_set_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: set\n"
"  Paramegers: (oaOccInstHeader,oaString)\n"
"    Calls: void set(oaOccInstHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccInstHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstHeaderObject* self=(PyoaStringAppDef_oaOccInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_isNull_doc[] =
"Class: oaStringAppDef_oaOccInstHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccInstHeader_assign_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccInstHeader data;
  int convert_status=PyoaStringAppDef_oaOccInstHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccInstHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccInstHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccInstHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccInstHeader_get,METH_VARARGS,oaStringAppDef_oaOccInstHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccInstHeader_getDefault,METH_VARARGS,oaStringAppDef_oaOccInstHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccInstHeader_set,METH_VARARGS,oaStringAppDef_oaOccInstHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccInstHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccInstHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccInstHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaOccInstHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccInstHeader)\n"
"    Calls: (const oaStringAppDef_oaOccInstHeader&)\n"
"    Signature: oaStringAppDef_oaOccInstHeader||cref-oaStringAppDef_oaOccInstHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccInstHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccInstHeader",
    sizeof(PyoaStringAppDef_oaOccInstHeaderObject),
    0,
    (destructor)oaStringAppDef_oaOccInstHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccInstHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccInstHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccInstHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccInstHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccInstHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::find(p1.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInstHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaOccInstHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccInstHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstHeaderp result= (oaStringAppDef_oaOccInstHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccInstHeader_FromoaStringAppDef_oaOccInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInstHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccInstHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccInstHeader_static_find,METH_VARARGS,oaStringAppDef_oaOccInstHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccInstHeader_static_get,METH_VARARGS,oaStringAppDef_oaOccInstHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccInstHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccInstHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccInstHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccInstHeader",
           (PyObject*)(&PyoaStringAppDef_oaOccInstHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccInstHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccInstHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaOccInstHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccInstTerm
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInstTerm_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccInstTerm_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccInstTermObject* self = (PyoaStringAppDef_oaOccInstTermObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccInstTerm)
    {
        PyParamoaStringAppDef_oaOccInstTerm p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccInstTerm_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccInstTerm, Choices are:\n"
        "    (oaStringAppDef_oaOccInstTerm)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccInstTerm_tp_dealloc(PyoaStringAppDef_oaOccInstTermObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccInstTerm_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccInstTerm value;
    int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaOccInstTerm::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccInstTerm_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccInstTerm v1;
    PyParamoaStringAppDef_oaOccInstTerm v2;
    int convert_status1=PyoaStringAppDef_oaOccInstTerm_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccInstTerm_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccInstTerm_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccInstTerm* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccInstTerm_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccInstTerm**) ((PyoaStringAppDef_oaOccInstTermObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccInstTerm Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(oaStringAppDef_oaOccInstTerm** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccInstTerm* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaOccInstTerm_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccInstTermObject* self = (PyoaStringAppDef_oaOccInstTermObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(oaStringAppDef_oaOccInstTerm* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccInstTerm_Type.tp_alloc(&PyoaStringAppDef_oaOccInstTerm_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccInstTermObject* self = (PyoaStringAppDef_oaOccInstTermObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_get_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: get\n"
"  Paramegers: (oaOccInstTerm,oaString)\n"
"    Calls: void get(const oaOccInstTerm* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccInstTerm,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstTerm data;
    int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstTermObject* self=(PyoaStringAppDef_oaOccInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstTerm data;
    int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstTermObject* self=(PyoaStringAppDef_oaOccInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_set_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: set\n"
"  Paramegers: (oaOccInstTerm,oaString)\n"
"    Calls: void set(oaOccInstTerm* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccInstTerm,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccInstTerm data;
    int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccInstTermObject* self=(PyoaStringAppDef_oaOccInstTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccInstTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccInstTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_isNull_doc[] =
"Class: oaStringAppDef_oaOccInstTerm, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccInstTerm data;
    int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccInstTerm_assign_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccInstTerm data;
  int convert_status=PyoaStringAppDef_oaOccInstTerm_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccInstTerm p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccInstTerm_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccInstTerm_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccInstTerm_get,METH_VARARGS,oaStringAppDef_oaOccInstTerm_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccInstTerm_getDefault,METH_VARARGS,oaStringAppDef_oaOccInstTerm_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccInstTerm_set,METH_VARARGS,oaStringAppDef_oaOccInstTerm_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccInstTerm_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccInstTerm_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccInstTerm_tp_assign,METH_VARARGS,oaStringAppDef_oaOccInstTerm_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccInstTerm)\n"
"    Calls: (const oaStringAppDef_oaOccInstTerm&)\n"
"    Signature: oaStringAppDef_oaOccInstTerm||cref-oaStringAppDef_oaOccInstTerm,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccInstTerm_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccInstTerm",
    sizeof(PyoaStringAppDef_oaOccInstTermObject),
    0,
    (destructor)oaStringAppDef_oaOccInstTerm_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccInstTerm_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccInstTerm_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccInstTerm_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccInstTerm_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccInstTerm_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_static_find_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::find(p1.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInstTerm, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccInstTerm_static_get_doc[] = 
"Class: oaStringAppDef_oaOccInstTerm, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccInstTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccInstTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccInstTerm_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccInstTermp result= (oaStringAppDef_oaOccInstTerm::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccInstTerm_FromoaStringAppDef_oaOccInstTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccInstTerm, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccInstTerm_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccInstTerm_static_find,METH_VARARGS,oaStringAppDef_oaOccInstTerm_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccInstTerm_static_get,METH_VARARGS,oaStringAppDef_oaOccInstTerm_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccInstTerm_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccInstTerm_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccInstTerm\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccInstTerm",
           (PyObject*)(&PyoaStringAppDef_oaOccInstTerm_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccInstTerm\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccInstTerm_Type.tp_dict;
    for(method=oaStringAppDef_oaOccInstTerm_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccModuleInstHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccModuleInstHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccModuleInstHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccModuleInstHeaderObject* self = (PyoaStringAppDef_oaOccModuleInstHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccModuleInstHeader)
    {
        PyParamoaStringAppDef_oaOccModuleInstHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccModuleInstHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccModuleInstHeader, Choices are:\n"
        "    (oaStringAppDef_oaOccModuleInstHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccModuleInstHeader_tp_dealloc(PyoaStringAppDef_oaOccModuleInstHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccModuleInstHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccModuleInstHeader value;
    int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[58];
    sprintf(buffer,"<oaStringAppDef_oaOccModuleInstHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccModuleInstHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccModuleInstHeader v1;
    PyParamoaStringAppDef_oaOccModuleInstHeader v2;
    int convert_status1=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccModuleInstHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccModuleInstHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccModuleInstHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccModuleInstHeader**) ((PyoaStringAppDef_oaOccModuleInstHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccModuleInstHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(oaStringAppDef_oaOccModuleInstHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccModuleInstHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccModuleInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaOccModuleInstHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccModuleInstHeaderObject* self = (PyoaStringAppDef_oaOccModuleInstHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(oaStringAppDef_oaOccModuleInstHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccModuleInstHeader_Type.tp_alloc(&PyoaStringAppDef_oaOccModuleInstHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccModuleInstHeaderObject* self = (PyoaStringAppDef_oaOccModuleInstHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_get_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: get\n"
"  Paramegers: (oaOccModuleInstHeader,oaString)\n"
"    Calls: void get(const oaOccModuleInstHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccModuleInstHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccModuleInstHeaderObject* self=(PyoaStringAppDef_oaOccModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccModuleInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccModuleInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccModuleInstHeaderObject* self=(PyoaStringAppDef_oaOccModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_set_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: set\n"
"  Paramegers: (oaOccModuleInstHeader,oaString)\n"
"    Calls: void set(oaOccModuleInstHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccModuleInstHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccModuleInstHeaderObject* self=(PyoaStringAppDef_oaOccModuleInstHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccModuleInstHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccModuleInstHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_isNull_doc[] =
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccModuleInstHeader data;
    int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccModuleInstHeader_assign_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccModuleInstHeader data;
  int convert_status=PyoaStringAppDef_oaOccModuleInstHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccModuleInstHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccModuleInstHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccModuleInstHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_get,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_getDefault,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_set,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccModuleInstHeader)\n"
"    Calls: (const oaStringAppDef_oaOccModuleInstHeader&)\n"
"    Signature: oaStringAppDef_oaOccModuleInstHeader||cref-oaStringAppDef_oaOccModuleInstHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccModuleInstHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccModuleInstHeader",
    sizeof(PyoaStringAppDef_oaOccModuleInstHeaderObject),
    0,
    (destructor)oaStringAppDef_oaOccModuleInstHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccModuleInstHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccModuleInstHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccModuleInstHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccModuleInstHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccModuleInstHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::find(p1.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccModuleInstHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccModuleInstHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaOccModuleInstHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccModuleInstHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccModuleInstHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccModuleInstHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccModuleInstHeaderp result= (oaStringAppDef_oaOccModuleInstHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccModuleInstHeader_FromoaStringAppDef_oaOccModuleInstHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccModuleInstHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccModuleInstHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_static_find,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccModuleInstHeader_static_get,METH_VARARGS,oaStringAppDef_oaOccModuleInstHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccModuleInstHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccModuleInstHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccModuleInstHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccModuleInstHeader",
           (PyObject*)(&PyoaStringAppDef_oaOccModuleInstHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccModuleInstHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccModuleInstHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaOccModuleInstHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccNet
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccNet_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccNet_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccNetObject* self = (PyoaStringAppDef_oaOccNetObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccNet)
    {
        PyParamoaStringAppDef_oaOccNet p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccNet_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccNet, Choices are:\n"
        "    (oaStringAppDef_oaOccNet)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccNet_tp_dealloc(PyoaStringAppDef_oaOccNetObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccNet_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccNet value;
    int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[45];
    sprintf(buffer,"<oaStringAppDef_oaOccNet::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccNet_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccNet v1;
    PyParamoaStringAppDef_oaOccNet v2;
    int convert_status1=PyoaStringAppDef_oaOccNet_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccNet_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccNet_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccNet* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccNet_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccNet**) ((PyoaStringAppDef_oaOccNetObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccNet Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(oaStringAppDef_oaOccNet** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccNet* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccNet_Type.tp_alloc(&PyoaStringAppDef_oaOccNet_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccNetObject* self = (PyoaStringAppDef_oaOccNetObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(oaStringAppDef_oaOccNet* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccNet_Type.tp_alloc(&PyoaStringAppDef_oaOccNet_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccNetObject* self = (PyoaStringAppDef_oaOccNetObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_get_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: get\n"
"  Paramegers: (oaOccNet,oaString)\n"
"    Calls: void get(const oaOccNet* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccNet,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccNet_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccNet data;
    int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccNetObject* self=(PyoaStringAppDef_oaOccNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccNet_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccNet data;
    int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccNetObject* self=(PyoaStringAppDef_oaOccNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_set_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: set\n"
"  Paramegers: (oaOccNet,oaString)\n"
"    Calls: void set(oaOccNet* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccNet,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccNet_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccNet data;
    int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccNetObject* self=(PyoaStringAppDef_oaOccNetObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccNet p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccNet_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_isNull_doc[] =
"Class: oaStringAppDef_oaOccNet, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccNet_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccNet data;
    int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccNet_assign_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccNet_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccNet data;
  int convert_status=PyoaStringAppDef_oaOccNet_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccNet p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccNet_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccNet_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccNet_get,METH_VARARGS,oaStringAppDef_oaOccNet_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccNet_getDefault,METH_VARARGS,oaStringAppDef_oaOccNet_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccNet_set,METH_VARARGS,oaStringAppDef_oaOccNet_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccNet_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccNet_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccNet_tp_assign,METH_VARARGS,oaStringAppDef_oaOccNet_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_doc[] = 
"Class: oaStringAppDef_oaOccNet\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccNet)\n"
"    Calls: (const oaStringAppDef_oaOccNet&)\n"
"    Signature: oaStringAppDef_oaOccNet||cref-oaStringAppDef_oaOccNet,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccNet_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccNet",
    sizeof(PyoaStringAppDef_oaOccNetObject),
    0,
    (destructor)oaStringAppDef_oaOccNet_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccNet_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccNet_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccNet_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccNet_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccNet_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_static_find_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccNet* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccNet|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccNet* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccNet|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccNet_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::find(p1.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccNet, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccNet_static_get_doc[] = 
"Class: oaStringAppDef_oaOccNet, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccNet* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccNet|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccNet_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccNetp result= (oaStringAppDef_oaOccNet::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccNet_FromoaStringAppDef_oaOccNet(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccNet, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccNet_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccNet_static_find,METH_VARARGS,oaStringAppDef_oaOccNet_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccNet_static_get,METH_VARARGS,oaStringAppDef_oaOccNet_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccNet_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccNet_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccNet\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccNet",
           (PyObject*)(&PyoaStringAppDef_oaOccNet_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccNet\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccNet_Type.tp_dict;
    for(method=oaStringAppDef_oaOccNet_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccShape
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccShape_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccShape_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccShapeObject* self = (PyoaStringAppDef_oaOccShapeObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccShape)
    {
        PyParamoaStringAppDef_oaOccShape p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccShape_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccShape, Choices are:\n"
        "    (oaStringAppDef_oaOccShape)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccShape_tp_dealloc(PyoaStringAppDef_oaOccShapeObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccShape_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccShape value;
    int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[47];
    sprintf(buffer,"<oaStringAppDef_oaOccShape::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccShape_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccShape v1;
    PyParamoaStringAppDef_oaOccShape v2;
    int convert_status1=PyoaStringAppDef_oaOccShape_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccShape_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccShape_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccShape* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccShape_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccShape**) ((PyoaStringAppDef_oaOccShapeObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccShape Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(oaStringAppDef_oaOccShape** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccShape* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccShape_Type.tp_alloc(&PyoaStringAppDef_oaOccShape_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccShapeObject* self = (PyoaStringAppDef_oaOccShapeObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(oaStringAppDef_oaOccShape* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccShape_Type.tp_alloc(&PyoaStringAppDef_oaOccShape_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccShapeObject* self = (PyoaStringAppDef_oaOccShapeObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_get_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: get\n"
"  Paramegers: (oaOccShape,oaString)\n"
"    Calls: void get(const oaOccShape* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccShape,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccShape_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccShape data;
    int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccShapeObject* self=(PyoaStringAppDef_oaOccShapeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccShape p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccShape_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccShape_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccShape data;
    int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccShapeObject* self=(PyoaStringAppDef_oaOccShapeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_set_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: set\n"
"  Paramegers: (oaOccShape,oaString)\n"
"    Calls: void set(oaOccShape* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccShape,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccShape_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccShape data;
    int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccShapeObject* self=(PyoaStringAppDef_oaOccShapeObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccShape p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccShape_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_isNull_doc[] =
"Class: oaStringAppDef_oaOccShape, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccShape_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccShape data;
    int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccShape_assign_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccShape_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccShape data;
  int convert_status=PyoaStringAppDef_oaOccShape_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccShape p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccShape_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccShape_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccShape_get,METH_VARARGS,oaStringAppDef_oaOccShape_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccShape_getDefault,METH_VARARGS,oaStringAppDef_oaOccShape_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccShape_set,METH_VARARGS,oaStringAppDef_oaOccShape_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccShape_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccShape_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccShape_tp_assign,METH_VARARGS,oaStringAppDef_oaOccShape_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_doc[] = 
"Class: oaStringAppDef_oaOccShape\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccShape)\n"
"    Calls: (const oaStringAppDef_oaOccShape&)\n"
"    Signature: oaStringAppDef_oaOccShape||cref-oaStringAppDef_oaOccShape,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccShape_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccShape",
    sizeof(PyoaStringAppDef_oaOccShapeObject),
    0,
    (destructor)oaStringAppDef_oaOccShape_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccShape_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccShape_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccShape_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccShape_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccShape_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_static_find_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccShape* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccShape|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccShape* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccShape|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccShape_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::find(p1.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccShape, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccShape_static_get_doc[] = 
"Class: oaStringAppDef_oaOccShape, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccShape* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccShape|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccShape_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccShapep result= (oaStringAppDef_oaOccShape::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccShape_FromoaStringAppDef_oaOccShape(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccShape, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccShape_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccShape_static_find,METH_VARARGS,oaStringAppDef_oaOccShape_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccShape_static_get,METH_VARARGS,oaStringAppDef_oaOccShape_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccShape_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccShape_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccShape\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccShape",
           (PyObject*)(&PyoaStringAppDef_oaOccShape_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccShape\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccShape_Type.tp_dict;
    for(method=oaStringAppDef_oaOccShape_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccTerm
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccTerm_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccTerm_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccTermObject* self = (PyoaStringAppDef_oaOccTermObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccTerm)
    {
        PyParamoaStringAppDef_oaOccTerm p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccTerm_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccTerm, Choices are:\n"
        "    (oaStringAppDef_oaOccTerm)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccTerm_tp_dealloc(PyoaStringAppDef_oaOccTermObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccTerm_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccTerm value;
    int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[46];
    sprintf(buffer,"<oaStringAppDef_oaOccTerm::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccTerm_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccTerm v1;
    PyParamoaStringAppDef_oaOccTerm v2;
    int convert_status1=PyoaStringAppDef_oaOccTerm_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccTerm_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccTerm_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccTerm* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccTerm_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccTerm**) ((PyoaStringAppDef_oaOccTermObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccTerm Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(oaStringAppDef_oaOccTerm** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccTerm* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccTerm_Type.tp_alloc(&PyoaStringAppDef_oaOccTerm_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccTermObject* self = (PyoaStringAppDef_oaOccTermObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(oaStringAppDef_oaOccTerm* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccTerm_Type.tp_alloc(&PyoaStringAppDef_oaOccTerm_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccTermObject* self = (PyoaStringAppDef_oaOccTermObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_get_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: get\n"
"  Paramegers: (oaOccTerm,oaString)\n"
"    Calls: void get(const oaOccTerm* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccTerm,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccTerm data;
    int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccTermObject* self=(PyoaStringAppDef_oaOccTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccTerm data;
    int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccTermObject* self=(PyoaStringAppDef_oaOccTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_set_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: set\n"
"  Paramegers: (oaOccTerm,oaString)\n"
"    Calls: void set(oaOccTerm* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccTerm,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccTerm data;
    int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccTermObject* self=(PyoaStringAppDef_oaOccTermObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccTerm p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccTerm_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_isNull_doc[] =
"Class: oaStringAppDef_oaOccTerm, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccTerm data;
    int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccTerm_assign_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccTerm data;
  int convert_status=PyoaStringAppDef_oaOccTerm_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccTerm p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccTerm_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccTerm_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccTerm_get,METH_VARARGS,oaStringAppDef_oaOccTerm_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccTerm_getDefault,METH_VARARGS,oaStringAppDef_oaOccTerm_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccTerm_set,METH_VARARGS,oaStringAppDef_oaOccTerm_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccTerm_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccTerm_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccTerm_tp_assign,METH_VARARGS,oaStringAppDef_oaOccTerm_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_doc[] = 
"Class: oaStringAppDef_oaOccTerm\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccTerm)\n"
"    Calls: (const oaStringAppDef_oaOccTerm&)\n"
"    Signature: oaStringAppDef_oaOccTerm||cref-oaStringAppDef_oaOccTerm,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccTerm_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccTerm",
    sizeof(PyoaStringAppDef_oaOccTermObject),
    0,
    (destructor)oaStringAppDef_oaOccTerm_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccTerm_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccTerm_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccTerm_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccTerm_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccTerm_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_static_find_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccTerm* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccTerm|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccTerm* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::find(p1.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccTerm, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccTerm_static_get_doc[] = 
"Class: oaStringAppDef_oaOccTerm, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccTerm* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccTerm|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccTerm_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccTermp result= (oaStringAppDef_oaOccTerm::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccTerm_FromoaStringAppDef_oaOccTerm(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccTerm, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccTerm_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccTerm_static_find,METH_VARARGS,oaStringAppDef_oaOccTerm_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccTerm_static_get,METH_VARARGS,oaStringAppDef_oaOccTerm_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccTerm_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccTerm_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccTerm\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccTerm",
           (PyObject*)(&PyoaStringAppDef_oaOccTerm_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccTerm\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccTerm_Type.tp_dict;
    for(method=oaStringAppDef_oaOccTerm_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccVectorInstDef
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccVectorInstDef_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccVectorInstDef_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccVectorInstDefObject* self = (PyoaStringAppDef_oaOccVectorInstDefObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccVectorInstDef)
    {
        PyParamoaStringAppDef_oaOccVectorInstDef p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccVectorInstDef_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccVectorInstDef, Choices are:\n"
        "    (oaStringAppDef_oaOccVectorInstDef)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccVectorInstDef_tp_dealloc(PyoaStringAppDef_oaOccVectorInstDefObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccVectorInstDef_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccVectorInstDef value;
    int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[55];
    sprintf(buffer,"<oaStringAppDef_oaOccVectorInstDef::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccVectorInstDef_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccVectorInstDef v1;
    PyParamoaStringAppDef_oaOccVectorInstDef v2;
    int convert_status1=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccVectorInstDef_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccVectorInstDef* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccVectorInstDef_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccVectorInstDef**) ((PyoaStringAppDef_oaOccVectorInstDefObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccVectorInstDef Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(oaStringAppDef_oaOccVectorInstDef** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccVectorInstDef* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccVectorInstDef_Type.tp_alloc(&PyoaStringAppDef_oaOccVectorInstDef_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccVectorInstDefObject* self = (PyoaStringAppDef_oaOccVectorInstDefObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(oaStringAppDef_oaOccVectorInstDef* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccVectorInstDef_Type.tp_alloc(&PyoaStringAppDef_oaOccVectorInstDef_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccVectorInstDefObject* self = (PyoaStringAppDef_oaOccVectorInstDefObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_get_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: get\n"
"  Paramegers: (oaOccVectorInstDef,oaString)\n"
"    Calls: void get(const oaOccVectorInstDef* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccVectorInstDef,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccVectorInstDefObject* self=(PyoaStringAppDef_oaOccVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccVectorInstDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccVectorInstDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccVectorInstDefObject* self=(PyoaStringAppDef_oaOccVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_set_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: set\n"
"  Paramegers: (oaOccVectorInstDef,oaString)\n"
"    Calls: void set(oaOccVectorInstDef* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccVectorInstDef,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccVectorInstDefObject* self=(PyoaStringAppDef_oaOccVectorInstDefObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccVectorInstDef p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccVectorInstDef_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_isNull_doc[] =
"Class: oaStringAppDef_oaOccVectorInstDef, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccVectorInstDef data;
    int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccVectorInstDef_assign_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccVectorInstDef data;
  int convert_status=PyoaStringAppDef_oaOccVectorInstDef_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccVectorInstDef p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccVectorInstDef_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccVectorInstDef_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_get,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_getDefault,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_set,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_tp_assign,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccVectorInstDef)\n"
"    Calls: (const oaStringAppDef_oaOccVectorInstDef&)\n"
"    Signature: oaStringAppDef_oaOccVectorInstDef||cref-oaStringAppDef_oaOccVectorInstDef,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccVectorInstDef_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccVectorInstDef",
    sizeof(PyoaStringAppDef_oaOccVectorInstDefObject),
    0,
    (destructor)oaStringAppDef_oaOccVectorInstDef_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccVectorInstDef_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccVectorInstDef_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccVectorInstDef_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccVectorInstDef_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccVectorInstDef_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_static_find_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::find(p1.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccVectorInstDef, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccVectorInstDef_static_get_doc[] = 
"Class: oaStringAppDef_oaOccVectorInstDef, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccVectorInstDef* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccVectorInstDef|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccVectorInstDef_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccVectorInstDefp result= (oaStringAppDef_oaOccVectorInstDef::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccVectorInstDef_FromoaStringAppDef_oaOccVectorInstDef(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccVectorInstDef, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccVectorInstDef_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_static_find,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccVectorInstDef_static_get,METH_VARARGS,oaStringAppDef_oaOccVectorInstDef_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccVectorInstDef_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccVectorInstDef_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccVectorInstDef\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccVectorInstDef",
           (PyObject*)(&PyoaStringAppDef_oaOccVectorInstDef_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccVectorInstDef\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccVectorInstDef_Type.tp_dict;
    for(method=oaStringAppDef_oaOccVectorInstDef_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOccurrence
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccurrence_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOccurrence_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOccurrenceObject* self = (PyoaStringAppDef_oaOccurrenceObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOccurrence)
    {
        PyParamoaStringAppDef_oaOccurrence p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOccurrence_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOccurrence, Choices are:\n"
        "    (oaStringAppDef_oaOccurrence)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOccurrence_tp_dealloc(PyoaStringAppDef_oaOccurrenceObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOccurrence_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOccurrence value;
    int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[49];
    sprintf(buffer,"<oaStringAppDef_oaOccurrence::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOccurrence_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOccurrence v1;
    PyParamoaStringAppDef_oaOccurrence v2;
    int convert_status1=PyoaStringAppDef_oaOccurrence_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOccurrence_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOccurrence_Convert(PyObject* ob,PyParamoaStringAppDef_oaOccurrence* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOccurrence_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOccurrence**) ((PyoaStringAppDef_oaOccurrenceObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOccurrence Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(oaStringAppDef_oaOccurrence** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOccurrence* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOccurrence_Type.tp_alloc(&PyoaStringAppDef_oaOccurrence_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOccurrenceObject* self = (PyoaStringAppDef_oaOccurrenceObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(oaStringAppDef_oaOccurrence* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOccurrence_Type.tp_alloc(&PyoaStringAppDef_oaOccurrence_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOccurrenceObject* self = (PyoaStringAppDef_oaOccurrenceObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_get_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: get\n"
"  Paramegers: (oaOccurrence,oaString)\n"
"    Calls: void get(const oaOccurrence* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOccurrence,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccurrence data;
    int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccurrenceObject* self=(PyoaStringAppDef_oaOccurrenceObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccurrence p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccurrence_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_getDefault_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccurrence data;
    int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccurrenceObject* self=(PyoaStringAppDef_oaOccurrenceObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_set_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: set\n"
"  Paramegers: (oaOccurrence,oaString)\n"
"    Calls: void set(oaOccurrence* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOccurrence,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOccurrence data;
    int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOccurrenceObject* self=(PyoaStringAppDef_oaOccurrenceObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOccurrence p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOccurrence_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_isNull_doc[] =
"Class: oaStringAppDef_oaOccurrence, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOccurrence data;
    int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOccurrence_assign_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOccurrence data;
  int convert_status=PyoaStringAppDef_oaOccurrence_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOccurrence p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOccurrence_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOccurrence_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOccurrence_get,METH_VARARGS,oaStringAppDef_oaOccurrence_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOccurrence_getDefault,METH_VARARGS,oaStringAppDef_oaOccurrence_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOccurrence_set,METH_VARARGS,oaStringAppDef_oaOccurrence_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOccurrence_tp_isNull,METH_VARARGS,oaStringAppDef_oaOccurrence_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOccurrence_tp_assign,METH_VARARGS,oaStringAppDef_oaOccurrence_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_doc[] = 
"Class: oaStringAppDef_oaOccurrence\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOccurrence)\n"
"    Calls: (const oaStringAppDef_oaOccurrence&)\n"
"    Signature: oaStringAppDef_oaOccurrence||cref-oaStringAppDef_oaOccurrence,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOccurrence_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOccurrence",
    sizeof(PyoaStringAppDef_oaOccurrenceObject),
    0,
    (destructor)oaStringAppDef_oaOccurrence_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOccurrence_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOccurrence_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOccurrence_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOccurrence_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOccurrence_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_static_find_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccurrence* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccurrence|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccurrence* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::find(p1.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccurrence, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOccurrence_static_get_doc[] = 
"Class: oaStringAppDef_oaOccurrence, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOccurrence* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOccurrence|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOccurrence_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOccurrencep result= (oaStringAppDef_oaOccurrence::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOccurrence_FromoaStringAppDef_oaOccurrence(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOccurrence, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOccurrence_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOccurrence_static_find,METH_VARARGS,oaStringAppDef_oaOccurrence_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOccurrence_static_get,METH_VARARGS,oaStringAppDef_oaOccurrence_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOccurrence_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOccurrence_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOccurrence\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOccurrence",
           (PyObject*)(&PyoaStringAppDef_oaOccurrence_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOccurrence\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOccurrence_Type.tp_dict;
    for(method=oaStringAppDef_oaOccurrence_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaOpPointHeader
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOpPointHeader_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaOpPointHeader_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaOpPointHeaderObject* self = (PyoaStringAppDef_oaOpPointHeaderObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaOpPointHeader)
    {
        PyParamoaStringAppDef_oaOpPointHeader p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaOpPointHeader_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaOpPointHeader, Choices are:\n"
        "    (oaStringAppDef_oaOpPointHeader)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaOpPointHeader_tp_dealloc(PyoaStringAppDef_oaOpPointHeaderObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaOpPointHeader_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaOpPointHeader value;
    int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[52];
    sprintf(buffer,"<oaStringAppDef_oaOpPointHeader::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaOpPointHeader_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaOpPointHeader v1;
    PyParamoaStringAppDef_oaOpPointHeader v2;
    int convert_status1=PyoaStringAppDef_oaOpPointHeader_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaOpPointHeader_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaOpPointHeader_Convert(PyObject* ob,PyParamoaStringAppDef_oaOpPointHeader* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaOpPointHeader_Check(ob)) {
        result->SetData( (oaStringAppDef_oaOpPointHeader**) ((PyoaStringAppDef_oaOpPointHeaderObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaOpPointHeader Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(oaStringAppDef_oaOpPointHeader** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaOpPointHeader* data=*value;
        PyObject* bself = PyoaStringAppDef_oaOpPointHeader_Type.tp_alloc(&PyoaStringAppDef_oaOpPointHeader_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaOpPointHeaderObject* self = (PyoaStringAppDef_oaOpPointHeaderObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(oaStringAppDef_oaOpPointHeader* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaOpPointHeader_Type.tp_alloc(&PyoaStringAppDef_oaOpPointHeader_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaOpPointHeaderObject* self = (PyoaStringAppDef_oaOpPointHeaderObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_get_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: get\n"
"  Paramegers: (oaOpPointHeader,oaString)\n"
"    Calls: void get(const oaOpPointHeader* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaOpPointHeader,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOpPointHeader data;
    int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOpPointHeaderObject* self=(PyoaStringAppDef_oaOpPointHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOpPointHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOpPointHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_getDefault_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOpPointHeader data;
    int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOpPointHeaderObject* self=(PyoaStringAppDef_oaOpPointHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_set_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: set\n"
"  Paramegers: (oaOpPointHeader,oaString)\n"
"    Calls: void set(oaOpPointHeader* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaOpPointHeader,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaOpPointHeader data;
    int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaOpPointHeaderObject* self=(PyoaStringAppDef_oaOpPointHeaderObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaOpPointHeader p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaOpPointHeader_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_isNull_doc[] =
"Class: oaStringAppDef_oaOpPointHeader, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaOpPointHeader data;
    int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaOpPointHeader_assign_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaOpPointHeader data;
  int convert_status=PyoaStringAppDef_oaOpPointHeader_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaOpPointHeader p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaOpPointHeader_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaOpPointHeader_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaOpPointHeader_get,METH_VARARGS,oaStringAppDef_oaOpPointHeader_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaOpPointHeader_getDefault,METH_VARARGS,oaStringAppDef_oaOpPointHeader_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaOpPointHeader_set,METH_VARARGS,oaStringAppDef_oaOpPointHeader_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaOpPointHeader_tp_isNull,METH_VARARGS,oaStringAppDef_oaOpPointHeader_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaOpPointHeader_tp_assign,METH_VARARGS,oaStringAppDef_oaOpPointHeader_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaOpPointHeader)\n"
"    Calls: (const oaStringAppDef_oaOpPointHeader&)\n"
"    Signature: oaStringAppDef_oaOpPointHeader||cref-oaStringAppDef_oaOpPointHeader,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaOpPointHeader_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaOpPointHeader",
    sizeof(PyoaStringAppDef_oaOpPointHeaderObject),
    0,
    (destructor)oaStringAppDef_oaOpPointHeader_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaOpPointHeader_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaOpPointHeader_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaOpPointHeader_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaOpPointHeader_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaOpPointHeader_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_static_find_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::find(p1.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOpPointHeader, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaOpPointHeader_static_get_doc[] = 
"Class: oaStringAppDef_oaOpPointHeader, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaOpPointHeader* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaOpPointHeader|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaOpPointHeader_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaOpPointHeaderp result= (oaStringAppDef_oaOpPointHeader::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaOpPointHeader_FromoaStringAppDef_oaOpPointHeader(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaOpPointHeader, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaOpPointHeader_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaOpPointHeader_static_find,METH_VARARGS,oaStringAppDef_oaOpPointHeader_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaOpPointHeader_static_get,METH_VARARGS,oaStringAppDef_oaOpPointHeader_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaOpPointHeader_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaOpPointHeader_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaOpPointHeader\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaOpPointHeader",
           (PyObject*)(&PyoaStringAppDef_oaOpPointHeader_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaOpPointHeader\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaOpPointHeader_Type.tp_dict;
    for(method=oaStringAppDef_oaOpPointHeader_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaParasiticNetwork
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaParasiticNetwork_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaParasiticNetwork_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaParasiticNetworkObject* self = (PyoaStringAppDef_oaParasiticNetworkObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaParasiticNetwork)
    {
        PyParamoaStringAppDef_oaParasiticNetwork p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaParasiticNetwork_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaParasiticNetwork, Choices are:\n"
        "    (oaStringAppDef_oaParasiticNetwork)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaParasiticNetwork_tp_dealloc(PyoaStringAppDef_oaParasiticNetworkObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaParasiticNetwork_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaParasiticNetwork value;
    int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[55];
    sprintf(buffer,"<oaStringAppDef_oaParasiticNetwork::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaParasiticNetwork_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaParasiticNetwork v1;
    PyParamoaStringAppDef_oaParasiticNetwork v2;
    int convert_status1=PyoaStringAppDef_oaParasiticNetwork_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaParasiticNetwork_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaParasiticNetwork_Convert(PyObject* ob,PyParamoaStringAppDef_oaParasiticNetwork* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaParasiticNetwork_Check(ob)) {
        result->SetData( (oaStringAppDef_oaParasiticNetwork**) ((PyoaStringAppDef_oaParasiticNetworkObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaParasiticNetwork Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(oaStringAppDef_oaParasiticNetwork** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaParasiticNetwork* data=*value;
        PyObject* bself = PyoaStringAppDef_oaParasiticNetwork_Type.tp_alloc(&PyoaStringAppDef_oaParasiticNetwork_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaParasiticNetworkObject* self = (PyoaStringAppDef_oaParasiticNetworkObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(oaStringAppDef_oaParasiticNetwork* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaParasiticNetwork_Type.tp_alloc(&PyoaStringAppDef_oaParasiticNetwork_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaParasiticNetworkObject* self = (PyoaStringAppDef_oaParasiticNetworkObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_get_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: get\n"
"  Paramegers: (oaParasiticNetwork,oaString)\n"
"    Calls: void get(const oaParasiticNetwork* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaParasiticNetwork,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaParasiticNetwork data;
    int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaParasiticNetworkObject* self=(PyoaStringAppDef_oaParasiticNetworkObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaParasiticNetwork p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaParasiticNetwork_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_getDefault_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaParasiticNetwork data;
    int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaParasiticNetworkObject* self=(PyoaStringAppDef_oaParasiticNetworkObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_set_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: set\n"
"  Paramegers: (oaParasiticNetwork,oaString)\n"
"    Calls: void set(oaParasiticNetwork* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaParasiticNetwork,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaParasiticNetwork data;
    int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaParasiticNetworkObject* self=(PyoaStringAppDef_oaParasiticNetworkObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaParasiticNetwork p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaParasiticNetwork_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_isNull_doc[] =
"Class: oaStringAppDef_oaParasiticNetwork, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaParasiticNetwork data;
    int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaParasiticNetwork_assign_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaParasiticNetwork data;
  int convert_status=PyoaStringAppDef_oaParasiticNetwork_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaParasiticNetwork p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaParasiticNetwork_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaParasiticNetwork_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaParasiticNetwork_get,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaParasiticNetwork_getDefault,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaParasiticNetwork_set,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaParasiticNetwork_tp_isNull,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaParasiticNetwork_tp_assign,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaParasiticNetwork)\n"
"    Calls: (const oaStringAppDef_oaParasiticNetwork&)\n"
"    Signature: oaStringAppDef_oaParasiticNetwork||cref-oaStringAppDef_oaParasiticNetwork,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaParasiticNetwork_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaParasiticNetwork",
    sizeof(PyoaStringAppDef_oaParasiticNetworkObject),
    0,
    (destructor)oaStringAppDef_oaParasiticNetwork_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaParasiticNetwork_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaParasiticNetwork_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaParasiticNetwork_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaParasiticNetwork_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaParasiticNetwork_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_static_find_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::find(p1.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaParasiticNetwork, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaParasiticNetwork_static_get_doc[] = 
"Class: oaStringAppDef_oaParasiticNetwork, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaParasiticNetwork* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaParasiticNetwork|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaParasiticNetwork_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaParasiticNetworkp result= (oaStringAppDef_oaParasiticNetwork::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaParasiticNetwork_FromoaStringAppDef_oaParasiticNetwork(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaParasiticNetwork, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaParasiticNetwork_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaParasiticNetwork_static_find,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaParasiticNetwork_static_get,METH_VARARGS,oaStringAppDef_oaParasiticNetwork_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaParasiticNetwork_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaParasiticNetwork_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaParasiticNetwork\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaParasiticNetwork",
           (PyObject*)(&PyoaStringAppDef_oaParasiticNetwork_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaParasiticNetwork\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaParasiticNetwork_Type.tp_dict;
    for(method=oaStringAppDef_oaParasiticNetwork_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaPin
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaPin_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaPin_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaPinObject* self = (PyoaStringAppDef_oaPinObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaPin)
    {
        PyParamoaStringAppDef_oaPin p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaPin_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaPin, Choices are:\n"
        "    (oaStringAppDef_oaPin)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaPin_tp_dealloc(PyoaStringAppDef_oaPinObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaPin_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaPin value;
    int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[42];
    sprintf(buffer,"<oaStringAppDef_oaPin::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaPin_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaPin v1;
    PyParamoaStringAppDef_oaPin v2;
    int convert_status1=PyoaStringAppDef_oaPin_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaPin_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaPin_Convert(PyObject* ob,PyParamoaStringAppDef_oaPin* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaPin_Check(ob)) {
        result->SetData( (oaStringAppDef_oaPin**) ((PyoaStringAppDef_oaPinObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaPin Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(oaStringAppDef_oaPin** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaPin* data=*value;
        PyObject* bself = PyoaStringAppDef_oaPin_Type.tp_alloc(&PyoaStringAppDef_oaPin_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaPinObject* self = (PyoaStringAppDef_oaPinObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(oaStringAppDef_oaPin* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaPin_Type.tp_alloc(&PyoaStringAppDef_oaPin_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaPinObject* self = (PyoaStringAppDef_oaPinObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_get_doc[] = 
"Class: oaStringAppDef_oaPin, Function: get\n"
"  Paramegers: (oaPin,oaString)\n"
"    Calls: void get(const oaPin* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaPin,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaPin_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPin data;
    int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPinObject* self=(PyoaStringAppDef_oaPinObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaPin p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaPin_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_getDefault_doc[] = 
"Class: oaStringAppDef_oaPin, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaPin_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPin data;
    int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPinObject* self=(PyoaStringAppDef_oaPinObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_set_doc[] = 
"Class: oaStringAppDef_oaPin, Function: set\n"
"  Paramegers: (oaPin,oaString)\n"
"    Calls: void set(oaPin* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaPin,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaPin_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPin data;
    int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPinObject* self=(PyoaStringAppDef_oaPinObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaPin p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaPin_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_isNull_doc[] =
"Class: oaStringAppDef_oaPin, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaPin_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaPin data;
    int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaPin_assign_doc[] = 
"Class: oaStringAppDef_oaPin, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaPin_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaPin data;
  int convert_status=PyoaStringAppDef_oaPin_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaPin p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaPin_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaPin_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaPin_get,METH_VARARGS,oaStringAppDef_oaPin_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaPin_getDefault,METH_VARARGS,oaStringAppDef_oaPin_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaPin_set,METH_VARARGS,oaStringAppDef_oaPin_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaPin_tp_isNull,METH_VARARGS,oaStringAppDef_oaPin_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaPin_tp_assign,METH_VARARGS,oaStringAppDef_oaPin_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_doc[] = 
"Class: oaStringAppDef_oaPin\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaPin)\n"
"    Calls: (const oaStringAppDef_oaPin&)\n"
"    Signature: oaStringAppDef_oaPin||cref-oaStringAppDef_oaPin,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaPin_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaPin",
    sizeof(PyoaStringAppDef_oaPinObject),
    0,
    (destructor)oaStringAppDef_oaPin_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaPin_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaPin_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaPin_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaPin_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaPin_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_static_find_doc[] = 
"Class: oaStringAppDef_oaPin, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaPin* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaPin|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaPin* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaPin|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaPin_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::find(p1.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaPin, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPin_static_get_doc[] = 
"Class: oaStringAppDef_oaPin, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaPin* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaPin|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaPin_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPinp result= (oaStringAppDef_oaPin::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaPin_FromoaStringAppDef_oaPin(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaPin, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaPin_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaPin_static_find,METH_VARARGS,oaStringAppDef_oaPin_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaPin_static_get,METH_VARARGS,oaStringAppDef_oaPin_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaPin_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaPin_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaPin\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaPin",
           (PyObject*)(&PyoaStringAppDef_oaPin_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaPin\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaPin_Type.tp_dict;
    for(method=oaStringAppDef_oaPin_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaPoleResidue
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaPoleResidue_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaPoleResidue_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaPoleResidueObject* self = (PyoaStringAppDef_oaPoleResidueObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaPoleResidue)
    {
        PyParamoaStringAppDef_oaPoleResidue p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaPoleResidue_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaPoleResidue, Choices are:\n"
        "    (oaStringAppDef_oaPoleResidue)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaPoleResidue_tp_dealloc(PyoaStringAppDef_oaPoleResidueObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaPoleResidue_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaPoleResidue value;
    int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[50];
    sprintf(buffer,"<oaStringAppDef_oaPoleResidue::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaPoleResidue_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaPoleResidue v1;
    PyParamoaStringAppDef_oaPoleResidue v2;
    int convert_status1=PyoaStringAppDef_oaPoleResidue_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaPoleResidue_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaPoleResidue_Convert(PyObject* ob,PyParamoaStringAppDef_oaPoleResidue* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaPoleResidue_Check(ob)) {
        result->SetData( (oaStringAppDef_oaPoleResidue**) ((PyoaStringAppDef_oaPoleResidueObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaPoleResidue Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(oaStringAppDef_oaPoleResidue** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaPoleResidue* data=*value;
        PyObject* bself = PyoaStringAppDef_oaPoleResidue_Type.tp_alloc(&PyoaStringAppDef_oaPoleResidue_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaPoleResidueObject* self = (PyoaStringAppDef_oaPoleResidueObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(oaStringAppDef_oaPoleResidue* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaPoleResidue_Type.tp_alloc(&PyoaStringAppDef_oaPoleResidue_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaPoleResidueObject* self = (PyoaStringAppDef_oaPoleResidueObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_get_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: get\n"
"  Paramegers: (oaPoleResidue,oaString)\n"
"    Calls: void get(const oaPoleResidue* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaPoleResidue,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPoleResidue data;
    int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPoleResidueObject* self=(PyoaStringAppDef_oaPoleResidueObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaPoleResidue p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaPoleResidue_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_getDefault_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPoleResidue data;
    int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPoleResidueObject* self=(PyoaStringAppDef_oaPoleResidueObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_set_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: set\n"
"  Paramegers: (oaPoleResidue,oaString)\n"
"    Calls: void set(oaPoleResidue* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaPoleResidue,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaPoleResidue data;
    int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPoleResidueObject* self=(PyoaStringAppDef_oaPoleResidueObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaPoleResidue p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaPoleResidue_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_isNull_doc[] =
"Class: oaStringAppDef_oaPoleResidue, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaPoleResidue data;
    int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaPoleResidue_assign_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaPoleResidue data;
  int convert_status=PyoaStringAppDef_oaPoleResidue_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaPoleResidue p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaPoleResidue_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaPoleResidue_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaPoleResidue_get,METH_VARARGS,oaStringAppDef_oaPoleResidue_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaPoleResidue_getDefault,METH_VARARGS,oaStringAppDef_oaPoleResidue_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaPoleResidue_set,METH_VARARGS,oaStringAppDef_oaPoleResidue_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaPoleResidue_tp_isNull,METH_VARARGS,oaStringAppDef_oaPoleResidue_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaPoleResidue_tp_assign,METH_VARARGS,oaStringAppDef_oaPoleResidue_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_doc[] = 
"Class: oaStringAppDef_oaPoleResidue\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaPoleResidue)\n"
"    Calls: (const oaStringAppDef_oaPoleResidue&)\n"
"    Signature: oaStringAppDef_oaPoleResidue||cref-oaStringAppDef_oaPoleResidue,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaPoleResidue_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaPoleResidue",
    sizeof(PyoaStringAppDef_oaPoleResidueObject),
    0,
    (destructor)oaStringAppDef_oaPoleResidue_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaPoleResidue_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaPoleResidue_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaPoleResidue_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaPoleResidue_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaPoleResidue_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_static_find_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaPoleResidue* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaPoleResidue* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::find(p1.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaPoleResidue, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaPoleResidue_static_get_doc[] = 
"Class: oaStringAppDef_oaPoleResidue, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaPoleResidue* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaPoleResidue|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaPoleResidue_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPoleResiduep result= (oaStringAppDef_oaPoleResidue::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaPoleResidue_FromoaStringAppDef_oaPoleResidue(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaPoleResidue, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaPoleResidue_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaPoleResidue_static_find,METH_VARARGS,oaStringAppDef_oaPoleResidue_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaPoleResidue_static_get,METH_VARARGS,oaStringAppDef_oaPoleResidue_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaPoleResidue_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaPoleResidue_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaPoleResidue\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaPoleResidue",
           (PyObject*)(&PyoaStringAppDef_oaPoleResidue_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaPoleResidue\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaPoleResidue_Type.tp_dict;
    for(method=oaStringAppDef_oaPoleResidue_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}


/********************************************************************
 *   Copyright 2002-2008  LSI Corporation
 *
 *   Licensed under the Apache License, Version 2.0 (the "License");
 *   you may not use this file except in compliance with the License.
 *   You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 *   Unless required by applicable law or agreed to in writing, software
 *   distributed under the License is distributed on an "AS IS" BASIS,
 *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *   See the License for the specific language governing permissions and
 *   limitations under the License.
 *
 *******************************************************************/

#include "pyoa_header.h"


// ==================================================================
// Wrapper Implementation for Class: oaStringAppDef_oaProp
// ==================================================================


// ==================================================================
// Alloc/Dealloc Routines
// ==================================================================

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaProp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
  try {
    int is_raw=(type==&PyoaStringAppDef_oaProp_Type);
    PyObject* bself = type->tp_alloc(type,0);
    if (bself == NULL) return bself;
    PyoaStringAppDef_oaPropObject* self = (PyoaStringAppDef_oaPropObject*)bself;
    self->locks = NULL;
    self->borrow = 0;
    static char *kwlist [] = { NULL } ;
    // Case: (oaStringAppDef_oaProp)
    {
        PyParamoaStringAppDef_oaProp p1;
        if (PyArg_ParseTuple(args,(char*)"O&",
              &PyoaStringAppDef_oaProp_Convert,&p1)) {
            self->data=p1.Data();
            self->value=&(self->data);
            return bself;
        }
    }
    PyErr_Clear();
    // Case: ()
    {
        if (PyArg_ParseTuple(args,(char*)"")) {
          self->data=NULL;
          self->value=&(self->data);
          return bself;
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Constructor found for class: oaStringAppDef_oaProp, Choices are:\n"
        "    (oaStringAppDef_oaProp)\n"
    );
    Py_DECREF(self);
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static void
oaStringAppDef_oaProp_tp_dealloc(PyoaStringAppDef_oaPropObject* self)
{
    self->ob_type->tp_free((PyObject*)self);
}

// ------------------------------------------------------------------
static PyObject*
oaStringAppDef_oaProp_tp_repr(PyObject *ob)
{
    PyParamoaStringAppDef_oaProp value;
    int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&value);
    assert(convert_status!=0);
    PyObject* result;

    char buffer[43];
    sprintf(buffer,"<oaStringAppDef_oaProp::" DISPLAY_FORMAT ">",POINTER_AS_DISPLAY(value.DataCall()));
    result=PyString_FromString(buffer);
    return result;
}
        
// ------------------------------------------------------------------
static int
oaStringAppDef_oaProp_tp_compare(PyObject *ob1,PyObject* ob2)
{
    PyParamoaStringAppDef_oaProp v1;
    PyParamoaStringAppDef_oaProp v2;
    int convert_status1=PyoaStringAppDef_oaProp_Convert(ob1,&v1);
    int convert_status2=PyoaStringAppDef_oaProp_Convert(ob2,&v2);
    assert(convert_status1!=0);
    assert(convert_status2!=0);
    if (v1.DataCall()==v2.DataCall()) return 0;
    return 1;
}
        
// ------------------------------------------------------------------
int
PyoaStringAppDef_oaProp_Convert(PyObject* ob,PyParamoaStringAppDef_oaProp* result)
{
    if (ob == NULL) return 1;
    if (PyoaStringAppDef_oaProp_Check(ob)) {
        result->SetData( (oaStringAppDef_oaProp**) ((PyoaStringAppDef_oaPropObject*)ob)->value);
        return 1;
    }
    PyErr_SetString(PyExc_TypeError,
        "Convertion of parameter to class: oaStringAppDef_oaProp Failed");
    return 0;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(oaStringAppDef_oaProp** value,int borrow,PyObject* lock)
{
    if (value && *value) {
        oaStringAppDef_oaProp* data=*value;
        PyObject* bself = PyoaStringAppDef_oaProp_Type.tp_alloc(&PyoaStringAppDef_oaProp_Type,0);
        if (bself == NULL) return bself;
        PyoaStringAppDef_oaPropObject* self = (PyoaStringAppDef_oaPropObject*)bself;
        self->value = (oaObject**) value;
        self->data = NULL;
        self->locks = NULL;
        self->borrow = 0; // Ignore borrow flag, since we copied
       if (lock) PyoaLockObject(self->locks,lock);
        return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}
// ------------------------------------------------------------------
PyObject* PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(oaStringAppDef_oaProp* data)
{
    if (data) {
       PyObject* bself = PyoaStringAppDef_oaProp_Type.tp_alloc(&PyoaStringAppDef_oaProp_Type,0);
       if (bself == NULL) return bself;
       PyoaStringAppDef_oaPropObject* self = (PyoaStringAppDef_oaPropObject*)bself;
       self->data = (oaObject*) data;
       self->value = &(self->data);
       self->borrow = 0; 
       self->locks = NULL;
       return bself;
    }
    Py_INCREF(Py_None);
    return Py_None;
}

// ------------------------------------------------------------------
// FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_get_doc[] = 
"Class: oaStringAppDef_oaProp, Function: get\n"
"  Paramegers: (oaProp,oaString)\n"
"    Calls: void get(const oaProp* object,oaString& value)\n"
"    Signature: get|void-void|cptr-oaProp,ref-oaString,\n"
"    This function returns the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaProp_get(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaProp data;
    int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPropObject* self=(PyoaStringAppDef_oaPropObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaProp p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaProp_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->get(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_getDefault_doc[] = 
"Class: oaStringAppDef_oaProp, Function: getDefault\n"
"  Paramegers: (oaString)\n"
"    Calls: void getDefault(oaString& value) const\n"
"    Signature: getDefault|void-void|ref-oaString,\n"
"    BrowseData: 0,oaString\n"
"    This function fills out the default value for this string extension.\n"
"    value\n"
"    The string to be filled out with the default value\n"
;

static PyObject*
oaStringAppDef_oaProp_getDefault(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaProp data;
    int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPropObject* self=(PyoaStringAppDef_oaPropObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaString p1;
    if (PyArg_ParseTuple(args,"O&",
          &PyoaString_Convert,&p1)) {
        data.DataCall()->getDefault(p1.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_set_doc[] = 
"Class: oaStringAppDef_oaProp, Function: set\n"
"  Paramegers: (oaProp,oaString)\n"
"    Calls: void set(oaProp* object,const oaString& value)\n"
"    Signature: set|void-void|ptr-oaProp,cref-oaString,\n"
"    This function sets the value of this string extension.\n"
"    object\n"
"    The object type with which this extension is associated\n"
"    value\n"
"    The value of the string extension\n"
"    oacInvalidDesignObjectForAppDef\n"
;

static PyObject*
oaStringAppDef_oaProp_set(PyObject* ob, PyObject *args)
{
  try {
    PyParamoaStringAppDef_oaProp data;
    int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&data);
    assert(convert_status!=0);
    PyoaStringAppDef_oaPropObject* self=(PyoaStringAppDef_oaPropObject*)ob;
    if (!PyValidateDbObject(data.Data(),0)) return NULL;

    PyParamoaProp p1;
    PyParamoaString p2;
    if (PyArg_ParseTuple(args,"O&O&",
          &PyoaProp_Convert,&p1,
          &PyoaString_Convert,&p2)) {
        if (!PyValidateDbObject(p1.Data(),1)) return NULL;
        data.DataCall()->set(p1.Data(),p2.Data());
        Py_INCREF(Py_None);
        return Py_None;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_isNull_doc[] =
"Class: oaStringAppDef_oaProp, Function: isNull\n"
"  Parameters: () \n"
"    This functions returns 1 if the DbPointer is NULL, and 0 otherwise.\n"
;

static PyObject*
oaStringAppDef_oaProp_tp_isNull(PyObject* ob, PyObject *args)
{
    PyParamoaStringAppDef_oaProp data;
    int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&data);
    assert(convert_status!=0);
    if (data.DataCall()==NULL)
        return PyInt_FromLong(1);
    else
        return PyInt_FromLong(0);
}
static char oaStringAppDef_oaProp_assign_doc[] = 
"Class: oaStringAppDef_oaProp, Function: set\n"
"  Paramegers: (oaDouble)\n"
"    This function sets the current value.\n"
;

static PyObject*
oaStringAppDef_oaProp_tp_assign(PyObject* ob, PyObject *args)
{
  PyParamoaStringAppDef_oaProp data;
  int convert_status=PyoaStringAppDef_oaProp_Convert(ob,&data);
  assert(convert_status!=0);
  try {
    PyParamoaStringAppDef_oaProp p1;
    if (PyArg_ParseTuple(args,(char*)"O&",
          &PyoaStringAppDef_oaProp_Convert,&p1)) {
        data.Data()=p1.Data();
        Py_INCREF(ob);
        return ob;
    }
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}


// ------------------------------------------------------------------
//  Function Methods Table:
// ------------------------------------------------------------------

static PyMethodDef oaStringAppDef_oaProp_methodlist[] = {
    {"get",(PyCFunction)oaStringAppDef_oaProp_get,METH_VARARGS,oaStringAppDef_oaProp_get_doc},
    {"getDefault",(PyCFunction)oaStringAppDef_oaProp_getDefault,METH_VARARGS,oaStringAppDef_oaProp_getDefault_doc},
    {"set",(PyCFunction)oaStringAppDef_oaProp_set,METH_VARARGS,oaStringAppDef_oaProp_set_doc},
    {"isNull",(PyCFunction)oaStringAppDef_oaProp_tp_isNull,METH_VARARGS,oaStringAppDef_oaProp_isNull_doc},
    {"assign",(PyCFunction)oaStringAppDef_oaProp_tp_assign,METH_VARARGS,oaStringAppDef_oaProp_assign_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Object:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_doc[] = 
"Class: oaStringAppDef_oaProp\n"
"  The oaStringAppDef class implements an application-specific extension to a particular type of data in a database.\n"
"  When these classes are created, a string field is added to each object of the specified dataType. The default value of the string field is the empty string. Applications can use the new string field for whatever purpose is necessary.\n"
"  For additional information on defining and using AppDefs, see oaAppDef and Extending the Database in the Programmer's Guide.\n"
"Constructors:\n"
"  Paramegers: (oaStringAppDef_oaProp)\n"
"    Calls: (const oaStringAppDef_oaProp&)\n"
"    Signature: oaStringAppDef_oaProp||cref-oaStringAppDef_oaProp,\n"
;

// ------------------------------------------------------------------
PyTypeObject PyoaStringAppDef_oaProp_Type = {
    PyObject_HEAD_INIT(&PyType_Type)
    0,
    "oaStringAppDef_oaProp",
    sizeof(PyoaStringAppDef_oaPropObject),
    0,
    (destructor)oaStringAppDef_oaProp_tp_dealloc,	/* tp_dealloc */
    0,	/* tp_print */
    0,					/* tp_getattr */
    0,					/* tp_setattr */
    (cmpfunc)oaStringAppDef_oaProp_tp_compare,	/* tp_compare */
    (reprfunc)oaStringAppDef_oaProp_tp_repr,	/* tp_repr */
    0,					/* tp_as_number */
    0,					/* tp_as_sequence */
    0,					/* tp_as_mapping */
    0,					/* tp_as_hash */
    0,					/* tp_as_call */
    0,					/* tp_str */
    0,					/* tp_getattro */
    0,					/* tp_setattro */
    0,					/* tp_as_buffer */
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
    oaStringAppDef_oaProp_doc,	/* tp_doc */
    0,					/* tp_traverse */
    0,					/* tp_clear */
    0,					/* tp_richcompre */
    0,					/* tp_weaklistoffset */
    0,					/* tp_iter */
    0,					/* tp_iternext */
    oaStringAppDef_oaProp_methodlist,	/* tp_methods */
    0,					/* tp_members */
    0,					/* tp_getset */
    &PyoaAppDef_Type,	/* tp_base */
    0,					/* tp_dict */
    0,					/* tp_descr_get */
    0,					/* tp_descr_set */
    0,					/* tp_dictoffset */
    0,					/* tp_init */
    PyType_GenericAlloc,	/* tp_alloc */
    oaStringAppDef_oaProp_new,	/* tp_new */
    _PyObject_Del,	/* tp_free */
};


// ------------------------------------------------------------------
// Static FunctionMethods:
// ------------------------------------------------------------------

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_static_find_doc[] = 
"Class: oaStringAppDef_oaProp, Function: find\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaProp* find(const oaString& name)\n"
"    Signature: find|ptr-oaStringAppDef_oaProp|cref-oaString,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' if it exists.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaProp* find(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: find|ptr-oaStringAppDef_oaProp|cref-oaString,cptr-oaAppObjectDef,\n"
"    This function returns an oaStringAppDef object with this dataType and the specified 'name' that is associated with the specified object extension 'objDef'.\n"
"    name\n"
"    The name of the oaAppDef object to look for\n"
"    objDef\n"
"    A constant pointer to the object extension\n"
;

static PyObject*
oaStringAppDef_oaProp_static_find(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::find(p1.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::find(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaProp, function: find, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaAppObjectDef)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static char oaStringAppDef_oaProp_static_get_doc[] = 
"Class: oaStringAppDef_oaProp, Function: get\n"
"  Paramegers: (oaString)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name . You can create a string extension on any object except another extension.\n"
"    name\n"
"    The name given to the oaStringAppDef object\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name,const oaAppObjectDef* objDef)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
"  Paramegers: (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
"    Calls: oaStringAppDef_oaProp* get(const oaString& name,const oaAppObjectDef* objDef,const oaString& defValue,oaBoolean persist)\n"
"    Signature: get|ptr-oaStringAppDef_oaProp|cref-oaString,cptr-oaAppObjectDef,cref-oaString,simple-oaBoolean,\n"
"    This function constructs an oaStringAppDef class string extension with the specified name for the specified object extension.\n"
"    name\n"
"    The name of the string extension\n"
"    objDef\n"
"    The object extension with which to associate the extension\n"
"    defValue\n"
"    An optional default value\n"
"    persist\n"
"    Saves the oaStringAppDef data in the database\n"
"    oacAppDefExists\n"
;

static PyObject*
oaStringAppDef_oaProp_static_get(PyObject* ob, PyObject *args)
{
  try {
    // Case: (oaString)
    {
        PyParamoaString p1;
        if (PyArg_ParseTuple(args,"O&",
              &PyoaString_Convert,&p1)) {
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2)) {
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaString p2;
        PyParamoaBoolean p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaString_Convert,&p2,
              &PyoaBoolean_Convert,&p3)) {
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        if (PyArg_ParseTuple(args,"O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data(),p2.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        if (PyArg_ParseTuple(args,"O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data(),p2.Data(),p3.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    // Case: (oaString,oaAppObjectDef,oaString,oaBoolean)
    {
        PyParamoaString p1;
        PyParamoaAppObjectDef p2;
        PyParamoaString p3;
        PyParamoaBoolean p4;
        if (PyArg_ParseTuple(args,"O&O&O&O&",
              &PyoaString_Convert,&p1,
              &PyoaAppObjectDef_Convert,&p2,
              &PyoaString_Convert,&p3,
              &PyoaBoolean_Convert,&p4)) {
            if (!PyValidateDbObject(p2.Data(),2)) return NULL;
            oaStringAppDef_oaPropp result= (oaStringAppDef_oaProp::get(p1.Data(),p2.Data(),p3.Data(),p4.Data()));
            return PyoaStringAppDef_oaProp_FromoaStringAppDef_oaProp(result);
        }
    }
    PyErr_Clear();
    PyErr_SetString(PyExc_TypeError,
        "No Arg-Matching Function found for class: oaStringAppDef_oaProp, function: get, Choices are:\n"
        "    (oaString)\n"
        "    (oaString,oaString)\n"
        "    (oaString,oaString,oaBoolean)\n"
        "    (oaString,oaAppObjectDef)\n"
        "    (oaString,oaAppObjectDef,oaString)\n"
        "    (oaString,oaAppObjectDef,oaString,oaBoolean)\n"
    );
    return NULL;
  }
  catch (oaException &excp) {
    PyErr_OpenAccess(excp);
    return NULL;
  }
}

// ------------------------------------------------------------------
static PyMethodDef oaStringAppDef_oaProp_staticmethodlist[] = {
    {"static_find",(PyCFunction)oaStringAppDef_oaProp_static_find,METH_VARARGS,oaStringAppDef_oaProp_static_find_doc},
    {"static_get",(PyCFunction)oaStringAppDef_oaProp_static_get,METH_VARARGS,oaStringAppDef_oaProp_static_get_doc},
   {NULL,NULL,0,NULL}
};


// ------------------------------------------------------------------
//  Type Init:
// ------------------------------------------------------------------

int
PyoaStringAppDef_oaProp_TypeInit(PyObject* mod_dict)
{
    if (PyType_Ready(&PyoaStringAppDef_oaProp_Type)<0) {
      printf("** PyType_Ready failed for: oaStringAppDef_oaProp\n");
      return -1;
    }

    if (PyDict_SetItemString(mod_dict,"oaStringAppDef_oaProp",
           (PyObject*)(&PyoaStringAppDef_oaProp_Type))<0) {
       printf("** Failed to add type name to module dictionary for: oaStringAppDef_oaProp\n");
       return -1;
    }

    PyObject *dict, *value;
    PyMethodDef *method;
    dict=PyoaStringAppDef_oaProp_Type.tp_dict;
    for(method=oaStringAppDef_oaProp_staticmethodlist;method->ml_name!=NULL;method++) {
        value=PyCFunction_New(method,NULL);
    if (value==NULL) return -1;
        if (PyDict_SetItemString(dict,method->ml_name,value)!=0) {
        Py_DECREF(value);
            printf("** Failed to add static function to module dictionary for: %s\n",
                method->ml_name);
            return -1;
        }
        Py_DECREF(value);
    }
    return 0;
}

