//genMethods "-g" "-t" "Vertex*" "-h" "Array" "-I" "LINK/basic/Array.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef Vertex* _Vertex_;
typedef Array<Vertex* > _Array_Vertex__;

#define _Array_Vertex__DATA(x) ((Array<Vertex* >*) (EXTDATA(x)))
#define _Array_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<Vertex* > >::type))
#define _Array_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _Array_Vertex__CXX_DATA(x) (*(Array<Vertex* >*) (EXTDATA(VAL(x))))
#define _Array_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Array<Vertex* > >::type))
#define _Array_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Array_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute" "-w" "free_attribute" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute(SCM, SCM, int);
void free_attribute(SCM);

typedef AttributeBase _AttributeBase;

#define _AttributeBaseDATA(x) ((AttributeBase*) (EXTDATA(x)))
#define _AttributeBaseIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<AttributeBase >::type))
#define _AttributeBaseISNT_DATA(x) (!IS_DATA(x))

#define _AttributeBaseCXX_DATA(x) (*(AttributeBase*) (EXTDATA(VAL(x))))
#define _AttributeBaseCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<AttributeBase >::type))
#define _AttributeBaseCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>

void free_attribute(SCM p)
{
        //cout << "free_attribute" << endl;
        if (!EXTSTATICP(p))
                Register<AttributeBase>::deleteEntry(_AttributeBaseDATA(p));
}

void display_attribute(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (_AttributeBaseDATA(c))
                oss << *_AttributeBaseDATA(c);
	//ElementOps<AttributeBase>::displayItem(oss, _AttributeBaseDATA(c));
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_AttributeBaseMethods() {}

//genMethods "-g" "-t" "AttributeBase*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attributeptr" "-m" "mark_attributeptr" "-w" "free_attributeptr" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attributeptr(SCM, SCM, int);
void mark_attributeptr(SCM);
void free_attributeptr(SCM);

typedef AttributeBase* _AttributeBase_;

#define _AttributeBase_DATA(x) ((AttributeBase**) (EXTDATA(x)))
#define _AttributeBase_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<AttributeBase* >::type))
#define _AttributeBase_ISNT_DATA(x) (!IS_DATA(x))

#define _AttributeBase_CXX_DATA(x) (*(AttributeBase**) (EXTDATA(VAL(x))))
#define _AttributeBase_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<AttributeBase* >::type))
#define _AttributeBase_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>
void display_attributeptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_AttributeBase_DATA(c))
        oss << **_AttributeBase_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}
void mark_attributeptr(SCM p)
{
        //cout << "mark_attributeptr" << endl;
        Register<AttributeBase>::markEntry(*_AttributeBase_DATA(p));
}
void free_attributeptr(SCM p)
{
        //cout << "free_attributeptr" << endl;
        if (!EXTSTATICP(p)) {
                delete _AttributeBase_DATA(p);
        }
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_AttributeBase_Methods() {}

//genMethods "-t" "Attribute<Edge*>*" "-I" "LINK/graph/Attribute.h" "-I" "LINK/graph/Edge.h" "-d" "graph" "-y" "display_attribute_edgeptr" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute_edgeptr(SCM, SCM, int);

typedef Attribute<Edge*>* _Attribute_Edge___;

#define _Attribute_Edge___DATA(x) ((Attribute<Edge*>**) (EXTDATA(x)))
#define _Attribute_Edge___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<Edge*>* >::type))
#define _Attribute_Edge___ISNT_DATA(x) (!_Attribute_Edge___IS_DATA(x))

#define _Attribute_Edge___CXX_DATA(x) (*(Attribute<Edge*>**) (EXTDATA(VAL(x))))
#define _Attribute_Edge___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<Edge*>* >::type))
#define _Attribute_Edge___CXX_ISNT_DATA(x) (!_Attribute_Edge___CXX_IS_DATA(x))

#include <strstream.h>
#include <LINK/graph/GraphObject.h>

typedef Edge *EdgePtr;

#define EPTR(s)    (*(EdgePtr*) ((s)->storage_as.flonum.data))

void display_attribute_edgeptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Attribute_Edge___DATA(c))
        oss << **_Attribute_Edge___DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

static SCM findEdgePtrAttributeCmd(SCM name, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("find-edge-attribute: bad arg 1, symbol expected", name);
	if (!(gobj = getGraphObject(go)))
		Err("find-edge-attribute: bad arg 2, graph, edge, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	
	Edge *val;
	if (getAttribute(gobj, nm, val) == LINK_GET_ATTR_FAIL)
		Err("find-attribute: error retrieving attribute", name);
	
        Edge **w = new Edge *(val);
        return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                        Wrapper<Edge*>::name, (void *) w, LINK_DYNAMIC);
}

static SCM setEdgePtrAttributeCmd(SCM name, SCM val, SCM go)
{
	GraphObject *gobj;
        int& v_type = Wrapper<Edge*>::type;

	if (!SYMBOLP(name))
		Err("set-edge-attribute!: bad arg 1, symbol expected", name);

        if (!CXX_TYPEP(val, v_type))
               Err("set-edge-attribute!: bad arg 1, <edge*> expected", 
						val);
	if (!(gobj = getGraphObject(go)))
		Err("set-edge-attribute!: bad arg 3, graph, edge, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	Edge *value = EPTR(val);
	
	if (setAttribute(gobj, nm, value) == LINK_SET_ATTR_FAIL)
		Err("set-edge-attribute: error setting attribute", name);
	
	return UNDEFINED;
}

static SCM newEdgePtrAttributeCmd(SCM name, SCM val, SCM go)
{
	Graph *g;
        int& v_type = Wrapper<Edge*>::type;

	if (!SYMBOLP(name))
		Err("new-edge-attribute!: bad arg 1, symbol expected", name);
        if (!CXX_TYPEP(val, v_type))
               Err("new-edge-attribute!: bad arg 1, <edge*> expected", val);
	if (!(g = getGraph(go)))
		Err("new-attribute!: bad arg 3, graph expected", go);
	char *nm = PNAME(name);
	Edge *value = EPTR(val);

	if (newAttribute(g, nm, value) == LINK_NEW_ATTR_FAIL)
		Err("new-attribute: error creating attribute", name);
	
	return UNDEFINED;
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Attribute_Edge___Methods() 
{
        STk_add_new_cpp_primitive("find-edge-attribute", tc_subr_2,
                            (PRIMITIVE (*)(...))findEdgePtrAttributeCmd);
        STk_add_new_cpp_primitive("set-edge-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))setEdgePtrAttributeCmd);
        STk_add_new_cpp_primitive("new-edge-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))newEdgePtrAttributeCmd);
}
//genMethods "-t" "Attribute<String>*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute_stringptr" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute_stringptr(SCM, SCM, int);

typedef Attribute<String>* _Attribute_String__;

#define _Attribute_String__DATA(x) ((Attribute<String>**) (EXTDATA(x)))
#define _Attribute_String__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<String>* >::type))
#define _Attribute_String__ISNT_DATA(x) (!_Attribute_String__IS_DATA(x))

#define _Attribute_String__CXX_DATA(x) (*(Attribute<String>**) (EXTDATA(VAL(x))))
#define _Attribute_String__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<String>* >::type))
#define _Attribute_String__CXX_ISNT_DATA(x) (!_Attribute_String__CXX_IS_DATA(x))

#include <strstream.h>
#include <LINK/graph/GraphObject.h>

void display_attribute_stringptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	//ElementOps<String>::displayItem(oss,*_Attribute_String__DATA(c));
	if (*_Attribute_String__DATA(c))
        	oss << **_Attribute_String__DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

//#define STRING(s)    ((String) ((s)->storage_as.extension.data))

static SCM findStringAttributeCmd(SCM name, SCM go)
{
        GraphObject *gobj;

        if (!SYMBOLP(name))
                Err("find-string-attribute: bad arg 1, symbol expected", name);
        if (!(gobj = getGraphObject(go)))
                Err("find-string-attribute: bad arg 2, graph, vertex, or edge"
                    "expected", go);
        char *nm = PNAME(name);

        String val;
        if (getAttribute(gobj, nm, val) == LINK_GET_ATTR_FAIL)
                Err("find-string-attribute: error retrieving attribute", name);

        SCM str = STk_makestring(val);
        return str;
}

static SCM setStringAttributeCmd(SCM name, SCM val, SCM go)
{
        GraphObject *gobj;

        if (!SYMBOLP(name))
                Err("set-string-attribute!: bad arg 1, symbol expected", name);
        if (!STRINGP(val))
                Err("set-string-attribute!: bad arg 2, string expected", 
								val);
        if (!(gobj = getGraphObject(go)))
                Err("set-string-attribute!: bad arg 3, graph, vertex, or edge"
                    "expected", go);
        char *nm = PNAME(name);
       	String value = newString(STRING(val));  // LEAK!!!!!!!!!

        if (setAttribute(gobj, nm, value) == LINK_SET_ATTR_FAIL)
                Err("set-string-attribute: error setting attribute", name);

        return UNDEFINED;
}

static SCM newStringAttributeCmd(SCM name, SCM val, SCM go)
{
        Graph *g;

        if (!SYMBOLP(name))
                Err("new-string-attribute!: bad arg 1, symbol expected", name);
        if (!STRINGP(val))
                Err("new-string-attribute!: bad arg 2, string expected", val);
        if (!(g = getGraph(go)))
                Err("new-string-attribute!: bad arg 3, graph expected", go);
        char *nm = PNAME(name);
        String value = newString(STRING(val)); // LEAK!!!!!!!!!!

        if (newAttribute(g, nm, value) == LINK_NEW_ATTR_FAIL)
                Err("new-attribute: error creating attribute", name);

        return UNDEFINED;
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Attribute_String__Methods() 
{
        STk_add_new_cpp_primitive("find-string-attribute", tc_subr_2,
                                    (PRIMITIVE (*)(...))findStringAttributeCmd);
        STk_add_new_cpp_primitive("set-string-attribute!", tc_subr_3,
                                    (PRIMITIVE (*)(...))setStringAttributeCmd);
        STk_add_new_cpp_primitive("new-string-attribute!", tc_subr_3,
                                    (PRIMITIVE (*)(...))newStringAttributeCmd);
}
//genMethods "-t" "Attribute<Vertex*>*" "-I" "LINK/graph/Attribute.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" "-y" "display_attribute_vertexptr" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute_vertexptr(SCM, SCM, int);

typedef Attribute<Vertex*>* _Attribute_Vertex___;

#define _Attribute_Vertex___DATA(x) ((Attribute<Vertex*>**) (EXTDATA(x)))
#define _Attribute_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<Vertex*>* >::type))
#define _Attribute_Vertex___ISNT_DATA(x) (!_Attribute_Vertex___IS_DATA(x))

#define _Attribute_Vertex___CXX_DATA(x) (*(Attribute<Vertex*>**) (EXTDATA(VAL(x))))
#define _Attribute_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<Vertex*>* >::type))
#define _Attribute_Vertex___CXX_ISNT_DATA(x) (!_Attribute_Vertex___CXX_IS_DATA(x))


#include <strstream.h>
#include <LINK/graph/GraphObject.h>

typedef Vertex *VertexPtr;

#define VPTR(s)    (*(VertexPtr*) ((s)->storage_as.flonum.data))

void display_attribute_vertexptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Attribute_Vertex___DATA(c))
        	oss << **_Attribute_Vertex___DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

static SCM findVertexPtrAttributeCmd(SCM name, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("find-vertex-attribute: bad arg 1, symbol expected", name);
	if (!(gobj = getGraphObject(go)))
		Err("find-vertex-attribute: bad arg 2, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	
	Vertex *val;
	if (getAttribute(gobj, nm, val) == LINK_GET_ATTR_FAIL)
		Err("find-attribute: error retrieving attribute", name);
	
        Vertex **w = new Vertex *(val);
        return STk_make_CXXwrapper(Wrapper<Vertex*>::type,
                        Wrapper<Vertex*>::name, (void *) w, LINK_DYNAMIC);
}

static SCM setVertexPtrAttributeCmd(SCM name, SCM val, SCM go)
{
	GraphObject *gobj;
        int& v_type = Wrapper<Vertex*>::type;

	if (!SYMBOLP(name))
		Err("set-vertex-attribute!: bad arg 1, symbol expected", name);

        if (!CXX_TYPEP(val, v_type))
               Err("set-vertex-attribute!: bad arg 1, <vertex*> expected", 
						val);
	if (!(gobj = getGraphObject(go)))
		Err("set-vertex-attribute!: bad arg 3, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	Vertex *value = VPTR(val);
	
	if (setAttribute(gobj, nm, value) == LINK_SET_ATTR_FAIL)
		Err("set-vertex-attribute: error setting attribute", name);
	
	return UNDEFINED;
}

static SCM newVertexPtrAttributeCmd(SCM name, SCM val, SCM go)
{
	Graph *g;
        int& v_type = Wrapper<Vertex*>::type;

	if (!SYMBOLP(name))
		Err("new-vertex-attribute!: bad arg 1, symbol expected", name);
        if (!CXX_TYPEP(val, v_type))
               Err("new-vertex-attribute!: bad arg 1, <vertex*> expected", val);
	if (!(g = getGraph(go)))
		Err("new-attribute!: bad arg 3, graph expected", go);
	char *nm = PNAME(name);
	Vertex *value = VPTR(val);

	if (newAttribute(g, nm, value) == LINK_NEW_ATTR_FAIL)
		Err("new-attribute: error creating attribute", name);
	
	return UNDEFINED;
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Attribute_Vertex___Methods() 
{
        STk_add_new_cpp_primitive("find-vertex-attribute", tc_subr_2,
                            (PRIMITIVE (*)(...))findVertexPtrAttributeCmd);
        STk_add_new_cpp_primitive("set-vertex-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))setVertexPtrAttributeCmd);
        STk_add_new_cpp_primitive("new-vertex-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))newVertexPtrAttributeCmd);
}
//genMethods "-t" "Attribute<double>*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute_double" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute_doubleptr(SCM, SCM, int);

typedef Attribute<double>* _Attribute_double__;

#define _Attribute_double__DATA(x) ((Attribute<double>**) (EXTDATA(x)))
#define _Attribute_double__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<double>* >::type))
#define _Attribute_double__ISNT_DATA(x) (!_Attribute_double__IS_DATA(x))

#define _Attribute_double__CXX_DATA(x) (*(Attribute<double>**) (EXTDATA(VAL(x))))
#define _Attribute_double__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<double>* >::type))
#define _Attribute_double__CXX_ISNT_DATA(x) (!_Attribute_double__CXX_IS_DATA(x))

#include <strstream.h>
#include <LINK/graph/GraphObject.h>

#define DOUBLE(s)    (*(double*) ((s)->storage_as.flonum.data))

void display_attribute_doubleptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Attribute_double__DATA(c))
        	oss << **_Attribute_double__DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

static SCM findDoubleAttributeCmd(SCM name, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("find-double-attribute: bad arg 1, symbol expected", name);
	if (!(gobj = getGraphObject(go)))
		Err("find-double-attribute: bad arg 2, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	
	double val;
	if (getAttribute(gobj, nm, val) == LINK_GET_ATTR_FAIL)
		Err("find-attribute: error retrieving attribute", name);
	
	SCM ret_val = STk_makenumber(val);
	return ret_val;
}

static SCM setDoubleAttributeCmd(SCM name, SCM val, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("set-double-attribute!: bad arg 1, symbol expected", name);
	if (!NUMBERP(val))
		Err("set-double-attribute!: bad arg 2, number expected", val);
	if (!(gobj = getGraphObject(go)))
		Err("set-double-attribute!: bad arg 3, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	
	double value;
	if (INTEGERP(val))
		value = INTEGER(val);
	else
		value = DOUBLE(val);

	if (setAttribute(gobj, nm, value) == LINK_SET_ATTR_FAIL)
		Err("set-double-attribute: error setting attribute", name);
	
	return UNDEFINED;
}

static SCM newDoubleAttributeCmd(SCM name, SCM val, SCM go)
{
	Graph *g;

	if (!SYMBOLP(name))
		Err("new-double-attribute!: bad arg 1, symbol expected", name);
	if (!NUMBERP(val))
		Err("new-double-attribute!: bad arg 2, number expected", val);
	if (!(g = getGraph(go)))
		Err("new-attribute!: bad arg 3, graph expected", go);
	char *nm = PNAME(name);
	double value;
	if (INTEGERP(val))
		value = INTEGER(val);
	else
		value = DOUBLE(val);

	if (newAttribute(g, nm, value) == LINK_NEW_ATTR_FAIL)
		Err("new-attribute: error creating attribute", name);
	
	return UNDEFINED;
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Attribute_double__Methods() 
{
        STk_add_new_cpp_primitive("find-double-attribute", tc_subr_2,
                            (PRIMITIVE (*)(...))findDoubleAttributeCmd);
        STk_add_new_cpp_primitive("set-double-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))setDoubleAttributeCmd);
        STk_add_new_cpp_primitive("new-double-attribute!", tc_subr_3,
                            (PRIMITIVE (*)(...))newDoubleAttributeCmd);
}

//genMethods "-t" "Attribute<int>*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute_int" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_attribute_intptr(SCM, SCM, int);

typedef Attribute<int>* _Attribute_int__;

#define _Attribute_int__DATA(x) ((Attribute<int>**) (EXTDATA(x)))
#define _Attribute_int__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<int>* >::type))
#define _Attribute_int__ISNT_DATA(x) (!_Attribute_int__IS_DATA(x))

#define _Attribute_int__CXX_DATA(x) (*(Attribute<int>**) (EXTDATA(VAL(x))))
#define _Attribute_int__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Attribute<int>* >::type))
#define _Attribute_int__CXX_ISNT_DATA(x) (!_Attribute_int__CXX_IS_DATA(x))

#include <strstream.h>
#include <LINK/graph/GraphObject.h>

void display_attribute_intptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Attribute_int__DATA(c))
        	oss << **_Attribute_int__DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

static SCM findAttributeCmd(SCM name, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("find-attribute: bad arg 1, symbol expected", name);
	if (!(gobj = getGraphObject(go)))
		Err("find-attribute: bad arg 2, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	
	int val;
	if (getAttribute(gobj, nm, val) == LINK_GET_ATTR_FAIL)
		Err("find-attribute: error retrieving attribute", name);
	
	SCM ret_val = STk_makeinteger(val);
	return ret_val;
}

static SCM setAttributeCmd(SCM name, SCM val, SCM go)
{
	GraphObject *gobj;

	if (!SYMBOLP(name))
		Err("set-attribute!: bad arg 1, symbol expected", name);
	if (!INTEGERP(val))
		Err("set-attribute!: bad arg 2, integer expected", val);
	if (!(gobj = getGraphObject(go)))
		Err("set-attribute!: bad arg 3, graph, vertex, or edge"
		    "expected", go);
	char *nm = PNAME(name);
	int value = INTEGER(val);

	if (setAttribute(gobj, nm, value) == LINK_SET_ATTR_FAIL)
		Err("set-attribute: error setting attribute", name);
	
	return UNDEFINED;
}

static SCM newAttributeCmd(SCM name, SCM val, SCM go)
{
	Graph *g;

	if (!SYMBOLP(name))
		Err("new-attribute!: bad arg 1, symbol expected", name);
	if (!INTEGERP(val))
		Err("new-attribute!: bad arg 2, integer expected", val);
	if (!(g = getGraph(go)))
		Err("new-attribute!: bad arg 3, graph expected", go);
	char *nm = PNAME(name);
	int value = INTEGER(val);

	if (newAttribute(g, nm, value) == LINK_NEW_ATTR_FAIL)
		Err("new-attribute: error creating attribute", name);
	
	return UNDEFINED;
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Attribute_int__Methods() 
{
        STk_add_new_cpp_primitive("find-attribute", tc_subr_2,
                                    (PRIMITIVE (*)(...))findAttributeCmd);
        STk_add_new_cpp_primitive("set-attribute!", tc_subr_3,
                                    (PRIMITIVE (*)(...))setAttributeCmd);
        STk_add_new_cpp_primitive("new-attribute!", tc_subr_3,
                                    (PRIMITIVE (*)(...))newAttributeCmd);
}

//genMethods "-g" "-t" "AttributeBase*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef Collection<AttributeBase* > _Collection_AttributeBase__;

#define _Collection_AttributeBase__DATA(x) ((Collection<AttributeBase* >*) (EXTDATA(x)))
#define _Collection_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<AttributeBase* > >::type))
#define _Collection_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_AttributeBase__CXX_DATA(x) (*(Collection<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _Collection_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<AttributeBase* > >::type))
#define _Collection_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Edge* _Edge_;
typedef Collection<Edge* > _Collection_Edge__;

#define _Collection_Edge__DATA(x) ((Collection<Edge* >*) (EXTDATA(x)))
#define _Collection_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Edge* > >::type))
#define _Collection_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Edge__CXX_DATA(x) (*(Collection<Edge* >*) (EXTDATA(VAL(x))))
#define _Collection_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Edge* > >::type))
#define _Collection_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Graph* _Graph_;
typedef Collection<Graph* > _Collection_Graph__;

#define _Collection_Graph__DATA(x) ((Collection<Graph* >*) (EXTDATA(x)))
#define _Collection_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Graph* > >::type))
#define _Collection_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Graph__CXX_DATA(x) (*(Collection<Graph* >*) (EXTDATA(VAL(x))))
#define _Collection_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Graph* > >::type))
#define _Collection_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "Collection" "-c" "Vertex*" "-I" "LINK/graph/Vertex.h" "-I" "LINK/stkWrapper/SetFuncsWrapper.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/SetFuncsWrapper.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef Collection<Sequence<Vertex*> > _Collection_Sequence_Vertex___;

#define _Collection_Sequence_Vertex___DATA(x) ((Collection<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _Collection_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Sequence<Vertex*> > >::type))
#define _Collection_Sequence_Vertex___ISNT_DATA(x) (!_Collection_Sequence_Vertex___IS_DATA(x))

#define _Collection_Sequence_Vertex___CXX_DATA(x) (*(Collection<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Collection_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Sequence<Vertex*> > >::type))
#define _Collection_Sequence_Vertex___CXX_ISNT_DATA(x) (!_Collection_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "Collection" "-c" "Vertex*" "-I" "LINK/graph/Vertex.h" "-I" "LINK/stkWrapper/SetFuncsWrapper.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/SetFuncsWrapper.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef Collection<Set<Vertex*> > _Collection_Set_Vertex___;

#define _Collection_Set_Vertex___DATA(x) ((Collection<Set<Vertex*> >*) (EXTDATA(x)))
#define _Collection_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<Vertex*> > >::type))
#define _Collection_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Set_Vertex___CXX_DATA(x) (*(Collection<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Collection_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Set<Vertex*> > >::type))
#define _Collection_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "Collection" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef Collection<SubSet<Vertex*> > _Collection_SubSet_Vertex___;

#define _Collection_SubSet_Vertex___DATA(x) ((Collection<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _Collection_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<SubSet<Vertex*> > >::type))
#define _Collection_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_SubSet_Vertex___CXX_DATA(x) (*(Collection<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Collection_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<SubSet<Vertex*> > >::type))
#define _Collection_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "Collection" "-I" "LINK/basic/SetFuncs.h" "-I" "LINK/basic/Collection.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/SetFuncs.h>

#include <LINK/basic/Collection.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Vertex* _Vertex_;
typedef Collection<Vertex* > _Collection_Vertex__;

#define _Collection_Vertex__DATA(x) ((Collection<Vertex* >*) (EXTDATA(x)))
#define _Collection_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Vertex* > >::type))
#define _Collection_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _Collection_Vertex__CXX_DATA(x) (*(Collection<Vertex* >*) (EXTDATA(VAL(x))))
#define _Collection_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Collection<Vertex* > >::type))
#define _Collection_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Collection_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase*" "-h" "Container" "-I" "LINK/basic/Container.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef AttributeBase* _AttributeBase_;
typedef Container<AttributeBase* > _Container_AttributeBase__;

#define _Container_AttributeBase__DATA(x) ((Container<AttributeBase* >*) (EXTDATA(x)))
#define _Container_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<AttributeBase* > >::type))
#define _Container_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_AttributeBase__CXX_DATA(x) (*(Container<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _Container_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<AttributeBase* > >::type))
#define _Container_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "Container" "-I" "LINK/basic/Container.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Edge* _Edge_;
typedef Container<Edge* > _Container_Edge__;

#define _Container_Edge__DATA(x) ((Container<Edge* >*) (EXTDATA(x)))
#define _Container_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Edge* > >::type))
#define _Container_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Edge__CXX_DATA(x) (*(Container<Edge* >*) (EXTDATA(VAL(x))))
#define _Container_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Edge* > >::type))
#define _Container_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "Container" "-I" "LINK/basic/Container.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Graph* _Graph_;
typedef Container<Graph* > _Container_Graph__;

#define _Container_Graph__DATA(x) ((Container<Graph* >*) (EXTDATA(x)))
#define _Container_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Graph* > >::type))
#define _Container_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Graph__CXX_DATA(x) (*(Container<Graph* >*) (EXTDATA(VAL(x))))
#define _Container_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Graph* > >::type))
#define _Container_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "Container" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/Container.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef Container<Sequence<Vertex*> > _Container_Sequence_Vertex___;

#define _Container_Sequence_Vertex___DATA(x) ((Container<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _Container_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Sequence<Vertex*> > >::type))
#define _Container_Sequence_Vertex___ISNT_DATA(x) (!_Container_Sequence_Vertex___IS_DATA(x))

#define _Container_Sequence_Vertex___CXX_DATA(x) (*(Container<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Container_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Sequence<Vertex*> > >::type))
#define _Container_Sequence_Vertex___CXX_ISNT_DATA(x) (!_Container_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "Container" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef Container<Set<Vertex*> > _Container_Set_Vertex___;

#define _Container_Set_Vertex___DATA(x) ((Container<Set<Vertex*> >*) (EXTDATA(x)))
#define _Container_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<Vertex*> > >::type))
#define _Container_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Set_Vertex___CXX_DATA(x) (*(Container<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Container_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Set<Vertex*> > >::type))
#define _Container_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "Container" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/Container.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef Container<SubSet<Vertex*> > _Container_SubSet_Vertex___;

#define _Container_SubSet_Vertex___DATA(x) ((Container<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _Container_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<SubSet<Vertex*> > >::type))
#define _Container_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Container_SubSet_Vertex___CXX_DATA(x) (*(Container<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Container_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<SubSet<Vertex*> > >::type))
#define _Container_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "Container" "-I" "LINK/basic/Container.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Container.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>


typedef Vertex* _Vertex_;
typedef Container<Vertex* > _Container_Vertex__;

#define _Container_Vertex__DATA(x) ((Container<Vertex* >*) (EXTDATA(x)))
#define _Container_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Vertex* > >::type))
#define _Container_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _Container_Vertex__CXX_DATA(x) (*(Container<Vertex* >*) (EXTDATA(VAL(x))))
#define _Container_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Container<Vertex* > >::type))
#define _Container_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Container_Vertex__Methods() {}

//genMethods "-g" "-t" "Edge" "-I" "LINK/graph/Edge.h" "-d" "graph" "-y" "display_edge" "-w" "free_edge" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_edge(SCM, SCM, int);
void free_edge(SCM);

typedef Edge _Edge;

#define _EdgeDATA(x) ((Edge*) (EXTDATA(x)))
#define _EdgeIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Edge >::type))
#define _EdgeISNT_DATA(x) (!IS_DATA(x))

#define _EdgeCXX_DATA(x) (*(Edge*) (EXTDATA(VAL(x))))
#define _EdgeCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Edge >::type))
#define _EdgeCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>
void display_edge(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (_EdgeDATA(c))
        	oss << *_EdgeDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void free_edge(SCM p)
{
        //cout << "free_edge" << endl;
        if (!EXTSTATICP(p))
                Register<Edge>::deleteEntry(_EdgeDATA(p));
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_EdgeMethods() {}

//genMethods "-g" "-t" "Edge*" "-I" "LINK/graph/Edge.h" "-d" "graph" "-y" "display_edgeptr" "-m" "mark_edgeptr" "-w" "free_edgeptr" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_edgeptr(SCM, SCM, int);
void mark_edgeptr(SCM);
void free_edgeptr(SCM);

typedef Edge* _Edge_;

#define _Edge_DATA(x) ((Edge**) (EXTDATA(x)))
#define _Edge_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Edge* >::type))
#define _Edge_ISNT_DATA(x) (!IS_DATA(x))

#define _Edge_CXX_DATA(x) (*(Edge**) (EXTDATA(VAL(x))))
#define _Edge_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Edge* >::type))
#define _Edge_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>
void display_edgeptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Edge_DATA(c));
        	oss << **_Edge_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void mark_edgeptr(SCM p)
{
        //cout << "mark_edgeptr" << endl;
        Register<Edge>::markEntry(*_Edge_DATA(p));
}

void free_edgeptr(SCM p)
{
        //cout << "free_edgeptr" << endl;
        if (!EXTSTATICP(p)) {
                delete _Edge_DATA(p);
        }
}


static PRIMITIVE SizeEdgeCmd(SCM e)
{
        Edge *edge;
        int& etype = Wrapper<Edge*>::type;
        if (!CXX_TYPEP(e, etype))
                Err("size-edge: bad arg 1, <edge*> expected", e);
	edge = * (Edge**) CLASSDATA(e);
        int sz = edge->size();
        SCM result = STk_makeinteger(sz);
        return result;
}

static PRIMITIVE VerticesEdgeCmd(SCM e)
{
        Edge *edge;
        int& etype = Wrapper<Edge*>::type;
        if (!CXX_TYPEP(e, etype))
                Err("edge-vertices: bad arg 1, <edge*> expected", e);
	edge = * (Edge**) CLASSDATA(e);
        Collection<Vertex*>* s = edge->vertices();
	if (s->sortedQ()) { // undirected edge
		Set<Vertex*> *ss = new Set<Vertex*>(*s);
		return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
               	    Wrapper<Set<Vertex*> >::name, (void *) ss, LINK_DYNAMIC);
	} else {
		Sequence<Vertex*> *sq = new Sequence<Vertex*>(*s);
		return STk_make_CXXwrapper(Wrapper<Sequence<Vertex*> >::type,
               	    Wrapper<Sequence<Vertex*> >::name,(void *)sq,LINK_DYNAMIC);
	}
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Edge_Methods() 
{
        STk_add_new_cpp_primitive("size-edge", tc_subr_1,
                                    (PRIMITIVE (*)(...))SizeEdgeCmd);
        STk_add_new_cpp_primitive("edge-vertices", tc_subr_1,
                                    (PRIMITIVE (*)(...))VerticesEdgeCmd);
	addOneArgMethod("size",
			Wrapper<_Edge_ >::name,
			"size-edge", LINK_OVL);
	addOneArgMethod("vertices",
			Wrapper<_Edge_ >::name,
			"edge-vertices", LINK_OVL);
}
//genMethods "-g" "-t" "Graph" "-I" "LINK/graph/Graph.h" "-d" "graph" "-y" "display_graph" "-w" "free_graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef Graph _Graph;

#define _GraphDATA(x) ((Graph*) (EXTDATA(x)))
#define _GraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Graph >::type))
#define _GraphISNT_DATA(x) (!IS_DATA(x))

#define _GraphCXX_DATA(x) (*(Graph*) (EXTDATA(VAL(x))))
#define _GraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Graph >::type))
#define _GraphCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>
void display_graph(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (_GraphDATA(c))
        	oss << *_GraphDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void free_graph(SCM p)
{
        //cout << "free_graph" << endl;
        if (!EXTSTATICP(p)) {
                Register<Graph>::deleteEntry(_GraphDATA(p));
		delete _GraphDATA(p);
	}
}



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_GraphMethods() {}

//genMethods "-g" "-t" "Graph*" "-I" "LINK/graph/Graph.h" "-d" "graph" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" 

#include <iostream.h>
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef Graph* _Graph_;

#define _Graph_DATA(x) ((Graph**) (EXTDATA(x)))
#define _Graph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Graph* >::type))
#define _Graph_ISNT_DATA(x) (!IS_DATA(x))

#define _Graph_CXX_DATA(x) (*(Graph**) (EXTDATA(VAL(x))))
#define _Graph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Graph* >::type))
#define _Graph_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

//----------------------------------------------------------------------
#include <LINK/basic/Iterator.h>
#include <LINK/basic/Set.h>
#include <strstream.h>
#include <LINK/graph/Vertex.h>
#include <LINK/graph/Edge.h>
#include <LINK/graph/Graph.h>
#include <LINK/graph/UBinGraph.h>
#include <LINK/graph/DBinGraph.h>
#include <LINK/graph/UHyperGraph.h>
#include <LINK/graph/DHyperGraph.h>
#include <LINK/graph/Attribute.h>
#include <LINK/stkWrapper/CollectionWrapper.h>

#define CXX_DATA(x, type_check) (*((type_check)**) (EXTDATA(VAL(x))))
#define CXX_IS_DATA(x, type_check) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == type_check))


void display_graphptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (*_Graph_DATA(c))
        	oss << **_Graph_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void mark_graphptr(SCM p)
{
        Register<Graph>::markEntry(*_Graph_DATA(p));
}

void free_graphptr(SCM p)
{
        if (!EXTSTATICP(p)) {
                delete _Graph_DATA(p);
        }
}

static SCM wrapGraph(Graph *g)
{
    Graph **gp;

    if (!g)
	return Ntruth;

    switch (g->type()) {
	case MIXEDHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<HyperGraph>::type, 
				     Wrapper<HyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<HyperGraph*>::type,
                     Wrapper<HyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case UNDHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<UHyperGraph>::type, 
				     Wrapper<UHyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<UHyperGraph*>::type,
                     Wrapper<UHyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case DIRHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<DHyperGraph>::type, 
				     Wrapper<DHyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<DHyperGraph*>::type,
                     Wrapper<DHyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case MIXEDBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<BinGraph>::type, 
				     Wrapper<BinGraph>::name, 
				     g);
        	gp = new Graph *(g);
		//{
		//	Vertex *v = (*gp)->vertex(0);
		//	double d;
		//	getAttribute((GraphObject*) v, "tmp-x-coord", d);
		//	cout << "in wrapGraph v is: " << v << endl;
		//	cout << "in wrapGraph it is: " << d << endl;
		//}
        	return STk_make_CXXwrapper(Wrapper<BinGraph*>::type,
                     Wrapper<BinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case UNDBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<UBinGraph>::type, 
				     Wrapper<UBinGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<UBinGraph*>::type,
                     Wrapper<UBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case DIRBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<DBinGraph>::type, 
				     Wrapper<DBinGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<DBinGraph*>::type,
                     Wrapper<DBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_MIXEDHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<MHyperGraph>::type, 
				     Wrapper<MHyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MHyperGraph*>::type,
                     Wrapper<MHyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_UNDHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<MUHyperGraph>::type,
				     Wrapper<MUHyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MUHyperGraph*>::type,
                     Wrapper<MUHyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_DIRHYPERGRAPH:
        	Register<Graph>::createEntry(Wrapper<MDHyperGraph>::type,
				     Wrapper<MDHyperGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MDHyperGraph*>::type,
                     Wrapper<MDHyperGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_MIXEDBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<MBinGraph>::type, 
				     Wrapper<MBinGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MBinGraph*>::type,
                     Wrapper<MBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_UNDBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<MUBinGraph>::type, 
				     Wrapper<MUBinGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MUBinGraph*>::type,
                     Wrapper<MUBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	case M_DIRBINARYGRAPH:
        	Register<Graph>::createEntry(Wrapper<MDBinGraph>::type, 
				     Wrapper<MDBinGraph>::name, 
				     g);
        	gp = new Graph *(g);
        	return STk_make_CXXwrapper(Wrapper<MDBinGraph*>::type,
                     Wrapper<MDBinGraph*>::name, (void *) gp, LINK_DYNAMIC);
	default:
		Err("illegal graph type", NIL);
   }
   return NIL;
}

static PRIMITIVE AddSubgraphCmd(SCM g, SCM vs)
{
	Graph *gr, *g2;
        if (!(gr = getGraph(g)))
          Err("add-subgraph: bad arg 1, <graph*> expected", g);

        int& vset_type = Wrapper<Set<Vertex*> >::type;
        if (!CXX_TYPEP(vs, vset_type))
          Err("add-subgraph: bad arg 2, <set<vertex*>> expected", vs);

        Set<Vertex*> s = *(Set<Vertex*>*) CLASSDATA(vs);
	List<Vertex*> l; 
	Iterator<Vertex*> get_vert(&s);
	Vertex *v;
	while (get_vert(v))
		l.append(v);

	Vertex *sv = gr->addSubgraph(l);
	if (!sv) 
		return Ntruth;
        Vertex **w = new Vertex *(sv);
        return STk_make_CXXwrapper(Wrapper<Vertex*>::type,
                        Wrapper<Vertex*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE DissolveSubgraphCmd(SCM graph, SCM v1)
{
	Graph *g;
        int& v_type = Wrapper<Vertex*>::type;

        if (!(g = getGraph(graph)))
               Err("dissolve-subgraph: bad arg 1, <graph*> expected", graph);
        if (!CXX_TYPEP(v1, v_type))
               Err("dissolve-subgraph: bad arg 2, <vertex*> expected", v1);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v1);
        Set<Vertex*>* s = new Set<Vertex*>(g->dissolveSubgraph(vert1));
	if (!s)
		return Ntruth;
        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE InducedSubgraphCmd(SCM g, SCM vs, SCM clone_flag)
{
	Graph *gr, *g2;
        if (!(gr = getGraph(g)))
          Err("induced-subgraph: bad arg 1, <graph*> expected", g);

        int& vset_type = Wrapper<Set<Vertex*> >::type;
        if (!CXX_TYPEP(vs, vset_type))
          Err("induced-subgraph: bad arg 2, <set<vertex*>> expected", vs);

        Set<Vertex*> s = *(Set<Vertex*>*) CLASSDATA(vs);

	if (!INTEGERP(clone_flag))
          Err("induced-subgraph: bad arg 3, (0|1) (1->copy attributes)",
						clone_flag);
	
	g2 = gr->inducedSubgraph(s, INTEGER(clone_flag));
	return wrapGraph(g2);
}

static PRIMITIVE CopyGraphCmd(SCM g, SCM clone_flag)
{
	Graph *gr, *g2;
        if (!(gr = getGraph(g)))
          Err("copy-graph: bad arg 1, <graph*> expected", g);
	if (!INTEGERP(clone_flag))
          Err("copy-graph: bad arg 2, (0|1) (1->copy attributes)",clone_flag);
	
	g2 = gr->copyGraph(INTEGER(clone_flag));
	return wrapGraph(g2);
}

static PRIMITIVE MultiGraphCmd(SCM g, SCM clone_flag)
{
	Graph *gr, *g2;
        if (!(gr = getGraph(g)))
          Err("multi-graph: bad arg 1, <graph*> expected", g);
	if (!INTEGERP(clone_flag))
          Err("multi-graph: bad arg 2, (0|1) (1->copy attributes)",clone_flag);
	
	g2 = multiGraph(gr, INTEGER(clone_flag));
	return wrapGraph(g2);
}

static PRIMITIVE SimpleGraphCmd(SCM g, SCM clone_flag)
{
	Graph *gr, *g2;
        if (!(gr = getGraph(g)))
          Err("simple-graph: bad arg 1, <graph*> expected", g);
	if (!INTEGERP(clone_flag))
          Err("simple-graph: bad arg 2, (0|1) (1->copy attributes)",clone_flag);
	
	g2 = simpleGraph(gr, INTEGER(clone_flag));
	return wrapGraph(g2);
}

static PRIMITIVE NameGraphObjectCmd(SCM go)
{
       GraphObject *gr;
       if (!(gr = getGraphObject(go)))
          Err("graph-object-label: bad arg 1, <graph*>, <vertex*>, or <edge*> " 
				" expected", go);

       return STk_makestring(gr->name());
}


static PRIMITIVE AddVertexGraphCmd(SCM v, SCM g)
{
	Graph *gr;
	char *name;
        if (!(name = getName(v)))
                Err("add-vertex!: bad arg 1, <vertex*> expected", v);
        if (!(gr = getGraph(g)))
                Err("add-vertex!: bad arg 2, <graph*> was expected", g);

        Vertex *x = gr->addVertex(name);
        delete name;
	if (!x) 
		return Ntruth;
        Vertex **w = new Vertex *(x);
        return STk_make_CXXwrapper(Wrapper<Vertex*>::type,
                        Wrapper<Vertex*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE DeleteVertexGraphCmd(SCM v, SCM g)
{
	Graph *gr;
	char *name;
        if (!(name = getName(v)))
                Err("remove-vertex!: bad arg 1, <vertex*> expected", v);
        if (!(gr = getGraph(g)))
                Err("remove-vertex!: bad arg 2, <graph*> expected", g);

        Vertex *x = gr->findVertexByName(name);
        delete name;
	if (!x) 
		return Ntruth;
        gr->deleteVertex(x);
        return UNDEFINED;
              
}

static PRIMITIVE DeleteVertex2GraphCmd(SCM v, SCM g)
{
	Graph *gr;
	int& v_type = Wrapper<Vertex*>::type;

	if (!CXX_TYPEP(v, v_type))
                Err("remove-vertex!: bad arg 1, <vertex*> expected", v);
        if (!(gr = getGraph(g)))
                Err("remove-vertex!: bad arg 2, <graph*> expected", g);

	
        Vertex *x = *(Vertex**) CLASSDATA(v);
	if (!x) 
		return Ntruth;
        gr->deleteVertex(x);
        return UNDEFINED;
}


static PRIMITIVE AddVerticesGraphCmd(SCM lower, SCM upper, SCM g)
{
        Graph *gr;

        if (!INTEGERP(lower))
                Err("add-vertices!: bad arg 1, <integer> expected", lower);
        if (!INTEGERP(upper))
                Err("add-vertices!: bad arg 2, <integer> expected", upper);
        if (!(gr = getGraph(g)))
                Err("add-vertices!: bad arg 3, <graph*> expected", g);

        char *name;

        int i, low = INTEGER(lower), high = INTEGER(upper);
        if (low >= high)
                Err("add-vertex!: arg_1 < arg_2 must hold", NIL);

        for (i=low; i<=high; i++) {
                ostrstream oss;
                oss << i << ends;
                name = oss.str();
                gr->addVertex(name);
                delete name;
        }
        Set<Vertex*>* s = new Set<Vertex*>(gr->vertices());
	if (!s)
		return Ntruth;
        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE DeleteVerticesGraphCmd(SCM lower, SCM upper, SCM g)
{
        Graph *gr;

        if (!INTEGERP(lower))
                Err("remove-vertices!: bad arg 1, <integer> expected", lower);
        if (!INTEGERP(upper))
                Err("remove-vertices!: bad arg 2, <integer> expected", upper);
        if (!(gr = getGraph(g)))
                Err("remove-vertices!: bad arg 3, <graph*> expected", g);

        char *name;

        int i, low = INTEGER(lower), high = INTEGER(upper);
        if (low >= high)
                Err("add-vertex!: arg_1 < arg_2 must hold", NIL);

        for (i=low; i<=high; i++) {
                ostrstream oss;
                oss << i << ends;
                name = oss.str();
                gr->deleteVertex(name);
                delete name;
        }
        return UNDEFINED;
}

static PRIMITIVE AddEdgeGraphCmd(SCM vset, SCM g)
{
	Graph *gr;
        int& vset_type = Wrapper<Collection<Vertex*> >::type;


	Collection<Vertex*>* vc = 
			CollectionWrapper<Vertex*>::getCollection(vset);
	if (!vc) {
               Err("add-edge!: bad arg 1, <collection<vertex*>> expected",vset);
	}
        if (!(gr = getGraph(g)))
                Err("add-edge!: bad arg 2, <graph*> expected", g);

	Edge *e;
	if (vc->sortedQ()) {
        	e = gr->addEdge(*vc);
	} else {
        	e = gr->addEdge(*(Sequence<Vertex*>*) vc);
	}
        if (!e)
		return Ntruth;
        Edge **w = new Edge *(e);

        return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                Wrapper<Edge*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE DeleteEdgeGraphCmd(SCM vset, SCM g)
{
	Graph *gr;
        int& edge_type = Wrapper<Edge*>::type;

	Collection<Vertex*>* s = 
			CollectionWrapper<Vertex*>::getCollection(vset);

        if (!(gr = getGraph(g)))
                Err("remove-edge!: bad arg 2, <graph*> expected", g);
        if (s)
        	gr->deleteEdge(*s);
	else if (!CXX_TYPEP(vset, edge_type)) {
               		Err("remove-edge!: bad arg 1, <edge*> or "
			    "<collection<vertex*>> expected", vset);
	} 
	Edge *e = *(Edge**) CLASSDATA(vset);
        gr->deleteEdge(e);

        return UNDEFINED;
}

static PRIMITIVE VertexSetGraphCmd(SCM g)
{
        Graph *gr;
        if (!(gr = getGraph(g)))
                Err("vertex-set: bad arg 1, <graph*> expected", g);
        SortedArray<Vertex*> a = gr->vertices();
        Set<Vertex*>* s = new Set<Vertex*>(a);

        //Set<Vertex*>* s = new Set<Vertex*>(gr->vertices());  SEGFAULT (WHY?)
	if (!s)
		return Ntruth;

        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE EdgeSetGraphCmd(SCM g)
{
        Graph *gr;
        if (!(gr = getGraph(g)))
                Err("edge-set: bad arg 1, <graph*> expected", g);
        MSet<Edge*> a = gr->edges();
        MSet<Edge*>* s = new MSet<Edge*>(a);
	if (!s)
		return Ntruth;

        return STk_make_CXXwrapper(Wrapper<MSet<Edge*> >::type,
                Wrapper<MSet<Edge*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE VertexVectorGraphCmd(SCM g)
{
        Graph *gr;
        if (!(gr = getGraph(g)))
                Err("vertex-vector: bad arg 1, <graph*> expected", g);
        SortedArray<Vertex*> a = gr->vertices();
        SortedArray<Vertex*>* s = new SortedArray<Vertex*>(a);

        //SortedArray<Vertex*>* s = new SortedArray<Vertex*>(gr->vertices());SF
	if (!s)
		return Ntruth;

        return STk_make_CXXwrapper(Wrapper<Array<Vertex*> >::type,
                Wrapper<Array<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE MBinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MBinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MBinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MUBinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MUBinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MUBinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MDBinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MDBinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MDBinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE BinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new BinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new BinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE UBinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new UBinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new UBinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE DBinGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new DBinGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new DBinGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MHyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MHyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MHyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MUHyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MUHyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MUHyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MDHyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new MDHyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new MDHyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE HyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new HyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new HyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE UHyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new UHyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new UHyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE DHyperGraphCmd(SCM g)
{
        Tcl_HashEntry *p;
        Graph *ap, *gr;

	if (g == UNBOUND)
        	ap = new DHyperGraph;
	else if (!(gr = getGraph(g)))
                	Err("mbingraph: bad arg 1, <graph*> expected", g);
	else 
		ap = new DHyperGraph(*gr, CLONE);
        return wrapGraph(ap);
}

static PRIMITIVE MakeGraphExistingCmd(SCM vset, SCM eset)
{
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];

	Collection<Vertex*>* vc = 
			CollectionWrapper<Vertex*>::getCollection(vset);
	Collection<Set<Vertex*> >* ec = 
			CollectionWrapper<Set<Vertex*> >::getCollection(eset);

        //int& vset_type = Wrapper<Set<Vertex*> >::type;
        //int& eset_type = Wrapper<Set<Set<Vertex*> > >::type;
        //if (!CXX_TYPEP(vset, vset_type))
        //       Err("graph: bad arg 1, <set<vertex*>> expected", vset);
        //if (!CXX_TYPEP(eset, eset_type))
        //       Err("graph: bad arg 2, <set<set<vertex*>> expected", eset);
	//Set<Vertex*>* vertices = (Set<Vertex*>*) CLASSDATA(vset);
	//Set<Set<Vertex*> >* edges = (Set<Set<Vertex*> >*) CLASSDATA(eset);
        //g = makeGraph(*vertices, *edges);

        g = makeGraph(*vc, *ec);
	if (!g)
		return Ntruth;
        return wrapGraph(g);
}

static PRIMITIVE MakeGraphVertsEdgesCmd(SCM vset, SCM eset)
{
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];
	MSet<Vertex*> vrts;
	Set<Vertex*> verts;
	MSet<Edge*> edges;

	if (CollectionWrapper<Vertex*>::isMSet(vset) ||
	    CollectionWrapper<Vertex*>::isSet(vset)) {
		vrts = *(MSet<Vertex*>*) CLASSDATA(vset);
		verts = vrts;
	} else {
               Err("graph: bad arg 1, <set<vertex*>> expected", vset);
	}
	if (CollectionWrapper<Edge*>::isMSet(eset) ||
	    CollectionWrapper<Edge*>::isSet(eset)) {
		edges = *(Set<Edge*>*) CLASSDATA(eset);
	} else {
               Err("graph: bad arg 2, <set<edge*>> expected", eset);
	}

        g = makeGraph(verts, edges);
	return wrapGraph(g);
}

static PRIMITIVE MakeGraphEdgesIntCmd(SCM eset);

static PRIMITIVE MakeGraphFromScratchCmd(SCM gparms, int len)
{
	SCM vlist, elist;
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];
	Set<char*> verts;
	MSet<Set<char*> > edges;

	if (len == 0)
		return UBinGraphCmd(UNBOUND);
	else if (len == 1)
		return MakeGraphEdgesIntCmd(CAR(gparms));
	else {
		vlist = CAR(gparms);
		elist = CAR(CDR(gparms));
	}
	if (NCONSP(vlist)) {
               Err("graph: bad arg 1, list expected", vlist);
	}
	if (NCONSP(elist)) {
               Err("graph: bad arg 2, list of lists expected", elist);
	}
	
	SCM l=vlist, l2;
	for (;;) {
		if (NULLP(l))
			break;
		char *vname = getName(CAR(l));
		verts.insert(vname);
		l = CDR(l);
	}
	l = elist;
	for (;;) {
		if (NULLP(l))
			break;
		if (NCONSP(CAR(l)))
			Err("graph: bad arg 2.ill-formed edge list",elist);
		l2 = CAR(l);
		Set<char*> edge_verts;
		for (;;) {
			if (NULLP(l2))
				break;
			char *vname = getName(CAR(l2));
			edge_verts.insert(vname);
			l2 = CDR(l2);
		}
                edges.insert(edge_verts);
		l = CDR(l);
	}
        g = makeGraph(verts, edges);

	Iterator<char*> get_vname(&verts);
	char* v;
	while (get_vname(v)) delete v;
	Iterator<Set<char*> > get_ename(&edges);
	Set<char*> edge;
	while (get_ename(edge)) {
		Iterator<char*> get_vname(&edge);
		while (get_vname(v)) delete v;
	}

	return wrapGraph(g);
}

static PRIMITIVE MakeDigraphCmd()
{
        Tcl_HashEntry *p;
        Graph *ap, **app;

        ap = new DBinGraph;         
	if (!ap)
		return Ntruth;
        Register<Graph>::createEntry(Wrapper<DBinGraph>::type, 
				     Wrapper<DBinGraph>::name, ap);
        app = new Graph *(ap);
	if (!app)
		return Ntruth;

        return STk_make_CXXwrapper(Wrapper<DBinGraph*>::type,
                        Wrapper<DBinGraph*>::name, (void *) app, LINK_DYNAMIC);
}

static PRIMITIVE MakeDigraphExistingCmd(SCM vset, SCM eset)
{
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];

        int& vset_type = Wrapper<Set<Vertex*> >::type;
        int& eset_type = Wrapper<Set<Sequence<Vertex*> > >::type;
        if (!CXX_TYPEP(vset, vset_type))
               Err("digraph: bad arg 1, <set<vertex*>> expected", vset);
        if (!CXX_TYPEP(eset, eset_type))
               Err("digraph: bad arg 2, <set<sequece<vertex*>> expected", eset);

	Set<Vertex*>* vertices = (Set<Vertex*>*) CLASSDATA(vset);
	Set<Sequence<Vertex*> >* edges=
				(Set<Sequence<Vertex*> >*)CLASSDATA(eset);
        g = makeGraph(*vertices, *edges);
        return wrapGraph(g);
}

static PRIMITIVE MakeDigraphFromScratchCmd(SCM gparms, int len)
{
	SCM vlist, elist;
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];
	Set<char*> verts;
	MSet<Sequence<char*> > edges;

	if (len == 0)
		return MakeDigraphCmd();
	else if (len == 1)
		Err("MakeDigraphFromScratchCmd: one arg method not defined",
						gparms);
	else {
		vlist = CAR(gparms);
		elist = CAR(CDR(gparms));
	}
	if (NCONSP(vlist)) {
               Err("digraph: bad arg 1, list expected", vlist);
	}
	if (NCONSP(elist)) {
               Err("digraph: bad arg 2, list of lists expected", elist);
	}
	
	SCM l=vlist, l2;
	for (;;) {
		if (NULLP(l))
			break;
		char *vname = getName(CAR(l));
		verts.insert(vname);
		l = CDR(l);
	}
	l = elist;
	for (;;) {
		if (NULLP(l))
			break;
		if (NCONSP(CAR(l)))
			Err("graph: bad arg 2.ill-formed edge list",elist);
		l2 = CAR(l);
		Sequence<char*> edge_verts;
		for (;;) {
			if (NULLP(l2))
				break;
			char *vname = getName(CAR(l2));
			edge_verts.append(vname);
			l2 = CDR(l2);
		}
		edges.insert(edge_verts);
		l = CDR(l);
	}
        g = makeGraph(verts, edges);

	Iterator<char*> get_vname(&verts);
	char* v;
	while (get_vname(v)) delete v;
	Iterator<Sequence<char*> > get_ename(&edges);
	Sequence<char*> edge;
	while (get_ename(edge)) {
		Iterator<char*> get_vname(&edge);
		while (get_vname(v)) delete v;
	}

	return wrapGraph(g);
}

static PRIMITIVE LoadGraphCmd(SCM fname)
{
	char *fn = getName(fname);
	Graph *g = LoadGraph(fn);
	return wrapGraph(g);
}

static PRIMITIVE LoadDimacsGraphCmd(SCM fname)
{
	char *fn = getName(fname);
	Graph *g = LoadDimacsGraph(fn);
	return wrapGraph(g);
}

static PRIMITIVE SaveGraphCmd(SCM graph, SCM fname)
{
	char *fn = getName(fname);
	Graph *g = getGraph(graph);
	//cout << "ok.." << endl;
	int i = SaveGraph(g, fn);
	//cout << "done.." << i <<  endl;
	if (i)
		return Ntruth;
	else
		return Truth;
}

static PRIMITIVE SaveDimacsGraphCmd(SCM graph, SCM fname)
{
	char *fn = getName(fname);
	Graph *g = getGraph(graph);
	int i = SaveDimacsGraph(g, fn);
	if (i)	
		return Ntruth;
	else
		return Truth;
}


static PRIMITIVE AddEdgesFromScratchCmd(SCM elist, SCM graph)
{
        Tcl_HashEntry *p;
        int *e;
	char *vname;
	SCM l, l2;

	Graph* g;
        if (!(g = getGraph(graph)))
               Err("add-edges!: bad arg 2, <graph*> expected", graph);

	if (NCONSP(elist)) {
               Err("add-edges!: bad arg 1, list of lists expected", elist);
	}
	
	l = elist;
	for (;;) {
		if (NULLP(l))
			break;
		if (NCONSP(CAR(l)))
			Err("add-edges: bad arg 1,ill-formed edge list",elist);
		l2 = CAR(l);
		Sequence<Vertex*> edge_verts;
		for (;;) {
			if (NULLP(l2))
				break;
			vname = getName(CAR(l2));
			Vertex *v = g->findVertexByName(vname);
			if (v)
				edge_verts.insert(v);
			l2 = CDR(l2);
		}
		g->addEdge(edge_verts);
		l = CDR(l);
	}
	return UNDEFINED;
}

static PRIMITIVE DeleteEdgesFromScratchCmd(SCM elist, SCM graph)
{
        Tcl_HashEntry *p;
        int *e;
	char *vname;
	SCM l, l2;
	Graph* g;

	if (NCONSP(elist)) {
               Err("remove-edges!: bad arg 1, list of lists expected", elist);
	}

        if (!(g = getGraph(graph)))
               Err("remove-edges!: bad arg 2, <graph*> expected", graph);
	
	l = elist;
	for (;;) {
		if (NULLP(l))
			break;
		if (NCONSP(CAR(l)))
			Err("remove-edges!:bad arg 1,ill-formed list",elist);
		l2 = CAR(l);
		Sequence<Vertex*> edge_verts;
		for (;;) {
			if (NULLP(l2))
				break;
			vname = getName(CAR(l2));
			Vertex *v = g->findVertexByName(vname);
			if (v)
				edge_verts.append(v);
			l2 = CDR(l2);
		}
		g->deleteEdge(edge_verts);
		l = CDR(l);
	}
	return UNDEFINED;
}

static PRIMITIVE addGraphEdgesCmd(SCM eset, SCM graph)
{
        Tcl_HashEntry *p;
        int *e;
	char vname[10];
	MSet<Edge*> es;

	Graph* g;
        if (!(g = getGraph(graph)))
               Err("add-edges!: bad arg 2, graph expected", graph);

        if (CollectionWrapper<Sequence<Vertex*> >::isMSet(eset)) {
		MSet<Sequence<Vertex*> >* mms = (MSet<Sequence<Vertex*> >*) 
							CLASSDATA(eset);
		es = g->addEdges(*mms);
	} else if (CollectionWrapper<Sequence<Vertex*> >::isSet(eset)) {
		Set<Sequence<Vertex*> >* mms = (Set<Sequence<Vertex*> >*) 
							CLASSDATA(eset);
		es = g->addEdges(*mms);
	} else if (CollectionWrapper<Set<Vertex*> >::isMSet(eset)) {
		MSet<Set<Vertex*> >* mms = (MSet<Set<Vertex*> >*) 
							CLASSDATA(eset);
		es = g->addEdges(*mms);
	} else if (CollectionWrapper<Set<Vertex*> >::isSet(eset)) {
		Set<Set<Vertex*> >* mms = (Set<Set<Vertex*> >*) 
							CLASSDATA(eset);
		es = g->addEdges(*mms);
	} else
               Err("add-edges!: bad arg 1, set or mset of "
			" set or sequence of <vertex*>> expected", eset);

	MSet<Edge*>* ep = new MSet<Edge*>(es);
	if (!ep)
		return Ntruth;

        return STk_make_CXXwrapper(Wrapper<MSet<Edge*> >::type,
                        Wrapper<MSet<Edge*> >::name, (void *) ep, LINK_DYNAMIC);
}

static PRIMITIVE deleteGraphEdgesCmd(SCM eset, SCM graph)
{
        Tcl_HashEntry *p;
        int *e;
	char vname[10];

	Graph* g;
        if (!(g = getGraph(graph)))
               Err("remove-edges!: bad arg 2, graph expected", graph);

        if (CollectionWrapper<Sequence<Vertex*> >::isMSet(eset)) {
		MSet<Sequence<Vertex*> >* mms = (MSet<Sequence<Vertex*> >*) 
							CLASSDATA(eset);
		if (!mms) return Ntruth;
		g->deleteEdges(*mms);
	} else if (CollectionWrapper<Sequence<Vertex*> >::isSet(eset)) {
		Set<Sequence<Vertex*> >* mms = (Set<Sequence<Vertex*> >*) 
							CLASSDATA(eset);
		if (!mms) return Ntruth;
		g->deleteEdges(*mms);
	} else if (CollectionWrapper<Set<Vertex*> >::isMSet(eset)) {
		MSet<Set<Vertex*> >* mms = (MSet<Set<Vertex*> >*) 
							CLASSDATA(eset);
		if (!mms) return Ntruth;
		g->deleteEdges(*mms);
	} else if (CollectionWrapper<Set<Vertex*> >::isSet(eset)) {
		Set<Set<Vertex*> >* mms = (Set<Set<Vertex*> >*) 
							CLASSDATA(eset);
		if (!mms) return Ntruth;
		g->deleteEdges(*mms);
	} else
               Err("remove-edges!: bad arg 1, set or mset of "
			" set or sequence of <vertex*>> expected", eset);
        return UNDEFINED;
}

static PRIMITIVE MakeGraphEdgesIntCmd(SCM eset)
{
        Tcl_HashEntry *p;
        Graph *g, **gp;
        int *e;
	char vname[10];

        int& eset_type = Wrapper<MSet<Set<int*> > >::type;
        if (!CXX_TYPEP(eset, eset_type))
               Err("graph: bad arg 1, <mset<set<int*>> expected", eset);

	MSet<Set<int*> >* mms = (MSet<Set<int*> >*) CLASSDATA(eset);
        g = new MHyperGraph;
	if (!g) return Ntruth;
	Iterator<Set<int*> > get_set(mms);
	Set<int*> ms;
	while (get_set(ms)) {
		Iterator<int*> get_element(&ms);
		while (get_element(e)) {
			sprintf(vname, "%d", *e);
			g->addVertex((char*) vname);
		}
	}
	get_set.reset();
	/*while (get_set(ms)) {
		Set<int*> s = ms;
		g->addEdge(s);
	}*/
        Register<Graph>::createEntry(Wrapper<Graph>::type, 
				     Wrapper<Graph>::name, g);
        gp = new Graph *(g);
	if (!gp) return Ntruth;

        return STk_make_CXXwrapper(Wrapper<Graph*>::type,
                        Wrapper<Graph*>::name, (void *) gp, LINK_DYNAMIC);
}

static PRIMITIVE IsomorphicQCmd(SCM graph1, SCM graph2)
{
	Graph *g, *g2;

        if (!(g = getGraph(graph1)))
               Err("adjacent?: bad arg 1, <graph*> expected", graph1);
        if (!(g2 = getGraph(graph2)))
               Err("adjacent?: bad arg 2, <graph*> expected", graph2);

	if (g->isomorphicQ(g2))
		return Truth;
	else
		return Ntruth;
}

static PRIMITIVE AdjacentQCmd(SCM v1, SCM v2, SCM graph)
{
	Graph *g;
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v1, v_type))
               Err("adjacent?: bad arg 1, <vertex*> expected", v1);
        if (!CXX_TYPEP(v2, v_type))
               Err("adjacent?: bad arg 2, <vertex*> expected", v2);
        if (!(g = getGraph(graph)))
               Err("adjacent?: bad arg 3, <graph*> expected", graph);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v1);
	Vertex *vert2 = *(Vertex**) CLASSDATA(v2);

	SCM result;

	if (g->adjacentQ(vert1, vert2))
		result = Truth;
	else
		result = Ntruth;

	return result;
}


static PRIMITIVE IsEdgeCmd2(SCM vset, SCM graph)
{
        int& vset_type = Wrapper<Set<Vertex*> >::type;
	Graph *g;
        if (!CXX_TYPEP(vset, vset_type))
               Err("edge?: bad arg 1, <set<vertex*>> expected", vset);
        if (!(g = getGraph(graph)))
               Err("adjacent?: bad arg 2, <graph*> expected", graph);

        Set<Vertex*>* s = (Set<Vertex*>*) CLASSDATA(vset);

	Edge* e = g->isEdge(*s);
	if (e) {
		Edge** ep = new Edge*(e);
        	return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                        Wrapper<Edge*>::name, (void *) ep, LINK_DYNAMIC);
	} else
		return Ntruth;
}

static PRIMITIVE IsEdgeCmd(SCM v1, SCM v2, SCM graph)
{
	Graph *g;
        int& v_type = Wrapper<Vertex*>::type;
        if (!CXX_TYPEP(v1, v_type))
               Err("edge?: bad arg 1, <vertex*> expected", v1);
        if (!CXX_TYPEP(v2, v_type))
               Err("edge?: bad arg 2, <vertex*> expected", v2);
        if (!(g = getGraph(graph)))
               Err("adjacent?: bad arg 3, <graph*> expected", graph);

        Vertex* vert1 = *(Vertex**) CLASSDATA(v1);
        Vertex* vert2 = *(Vertex**) CLASSDATA(v2);

	Edge* e = g->isEdge(vert1, vert2);
	if (e) {
		Edge** ep = new Edge*(e);
        	return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                        Wrapper<Edge*>::name, (void *) ep, LINK_DYNAMIC);
	} else
		return Ntruth;
}

static PRIMITIVE IncidentEdgesCmd(SCM v)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("incident-edges: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	MSet<Edge*> inc_edges = g->incidentEdges(vert1);
	MSet<Edge*>* ep = new MSet<Edge*>(inc_edges);

        return STk_make_CXXwrapper(Wrapper<MSet<Edge*> >::type,
                        Wrapper<MSet<Edge*> >::name, (void *) ep, LINK_DYNAMIC);
}

static PRIMITIVE InIncidentEdgesCmd(SCM v)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("in-incident-edges: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	MSet<Edge*> inc_edges = g->inIncidentEdges(vert1);
	MSet<Edge*>* ep = new MSet<Edge*>(inc_edges);

        return STk_make_CXXwrapper(Wrapper<MSet<Edge*> >::type,
                        Wrapper<MSet<Edge*> >::name, (void *) ep, LINK_DYNAMIC);
}

static PRIMITIVE OutIncidentEdgesCmd(SCM v)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("out-incident-edges: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	MSet<Edge*> inc_edges = g->outIncidentEdges(vert1);
	MSet<Edge*>* ep = new MSet<Edge*>(inc_edges);

        return STk_make_CXXwrapper(Wrapper<MSet<Edge*> >::type,
                        Wrapper<MSet<Edge*> >::name, (void *) ep, LINK_DYNAMIC);
}

static PRIMITIVE DegreeCmd(SCM v)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("degree: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	SCM result;

	int degree = g->degree(vert1);

	result = STk_makeinteger(degree);
	return result;
}

static PRIMITIVE InDegreeCmd(SCM v, SCM graph)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("in-degree: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	SCM result;

	int degree = g->inDegree(vert1);

	result = STk_makeinteger(degree);
	return result;
}

static PRIMITIVE OutDegreeCmd(SCM v, SCM graph)
{
        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(v, v_type))
               Err("out-degree: bad arg 1, <vertex*> expected", v);

	Vertex *vert1 = *(Vertex**) CLASSDATA(v);
	Graph *g = vert1->owner();

	SCM result;

	int degree = g->outDegree(vert1);

	result = STk_makeinteger(degree);
	return result;
}

static PRIMITIVE OrderCmd(SCM graph)
{
	Graph *g;

        if (!(g = getGraph(graph)))
               Err("order: bad arg 1, graph expected", graph);

	SCM result;

	int order = g->order();

	result = STk_makeinteger(order);
	return result;
}

static PRIMITIVE SizeCmd(SCM graph)
{
	Graph *g;

        if (!(g = getGraph(graph)))
               Err("size: bad arg 1, graph expected", graph);

	SCM result;

	int size = g->size();

	result = STk_makeinteger(size);
	return result;
}

static PRIMITIVE VertexRefCmd(SCM graph, SCM rank)
{
	Graph *g;

	if (!INTEGERP(rank))
               Err("vertex-ref: bad arg 2, <integer> expected", rank);
        if (!(g = getGraph(graph)))
               Err("vertex-ref: bad arg 1, graph expected", graph);

	SCM result;

	int i = INTEGER(rank);
	Vertex *v = g->vertex(i);
	if (!v)
		return Ntruth;
        Vertex **w = new Vertex *(v);

        return STk_make_CXXwrapper(Wrapper<Vertex*>::type,
                        Wrapper<Vertex*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE FindVertexByNameCmd(SCM nm, SCM graph)
{
	Graph *g;

	char *name;
        if (!(name = getName(nm)))
                Err("find-vertex: bad arg 1, symbol or string expected", nm);
        if (!(g = getGraph(graph)))
               Err("find-vertex: bad arg 2, graph expected", graph);

	SCM result;

	Vertex *v = g->findVertexByName(name);
        Vertex **w = new Vertex *(v);

        return STk_make_CXXwrapper(Wrapper<Vertex*>::type,
                        Wrapper<Vertex*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE FindEdgeByNameCmd(SCM nm, SCM graph)
{
	Graph *g;

	char *name;
        if (!(name = getName(nm)))
                Err("find-edge: bad arg 1, symbol or string expected", nm);
        if (!(g = getGraph(graph)))
               Err("fin-edge: bad arg 2, graph expected", graph);

	SCM result;

	Edge *e = g->findEdgeByName(name);
        Edge **ep = new Edge *(e);

        return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                        Wrapper<Edge*>::name, (void *) ep, LINK_DYNAMIC);
}

static PRIMITIVE EdgeRefCmd(SCM graph, SCM rank)
{
	Graph *g;

	if (!INTEGERP(rank))
               Err("edge-ref: bad arg 2, <integer> expected", rank);
        if (!(g = getGraph(graph)))
               Err("edge-ref: bad arg 1, graph expected", graph);

	SCM result;

	int i = INTEGER(rank);
	Edge *v = g->edge(i);
	if (!v)
		return Ntruth;
        Edge **w = new Edge *(v);

        return STk_make_CXXwrapper(Wrapper<Edge*>::type,
                        Wrapper<Edge*>::name, (void *) w, LINK_DYNAMIC);
}

static PRIMITIVE VertexRankCmd(SCM vertex, SCM graph)
{
	Graph *g;

        int& v_type = Wrapper<Vertex*>::type;

        if (!CXX_TYPEP(vertex, v_type))
               Err("rank: bad arg 1, <vertex*> expected", vertex);
        if (!(g = getGraph(graph)))
               Err("rank: bad arg 2, graph expected", graph);

	SCM result;

	Vertex *v = *(Vertex**) CLASSDATA(vertex);
	int rank = g->rank(v);

	result = STk_makeinteger(rank);
	return result;
}

static PRIMITIVE EdgeRankCmd(SCM edge, SCM graph)
{
	Graph *g;

        int& e_type = Wrapper<Edge*>::type;

        if (!CXX_TYPEP(edge, e_type))
               Err("rank: bad arg 1, <edge*> expected", edge);
        if (!(g = getGraph(graph)))
               Err("rank: bad arg 2, graph expected", graph);

	SCM result;

	Edge *e = *(Edge**) CLASSDATA(edge);
	int rank = g->rank(e);

	result = STk_makeinteger(rank);
	return result;
}

static PRIMITIVE LineGraphCmd(SCM graph)
{
	Graph *g;
        if (!(g = getGraph(graph)))
               Err("line graph: bad arg 1, graph expected", graph);
	MBinGraph *mhg = (MBinGraph*) g;
        Graph *res = new MBinGraph(mhg->lineGraph());
	return wrapGraph(res);
}

static PRIMITIVE GraphComplementCmd(SCM graph)
{
	Graph *g;
        if (!(g = getGraph(graph)))
               Err("graph complement: bad arg 1, graph expected", graph);
	MBinGraph *mhg = (MBinGraph*) g;
        Graph *res = new MBinGraph(mhg->complement());
	return wrapGraph(res);
}

static PRIMITIVE GraphSumCmd(SCM graph1, SCM graph2)
{
	Graph *g1, *g2;
        if (!(g1 = getGraph(graph1)))
               Err("graph sum: bad arg 1, graph expected", graph1);
        if (!(g2 = getGraph(graph2)))
	       return graph1;
        Graph * res = new MBinGraph( (*(MBinGraph*)g1) + 
				         (*(MBinGraph*)g2));
	return wrapGraph(res);
}

static PRIMITIVE GraphProductCmd(SCM graph1, SCM graph2)
{
	Graph *g1, *g2;
        if (!(g1 = getGraph(graph1)))
               Err("graph product: bad arg 1, graph expected", graph1);
        if (!(g2 = getGraph(graph2)))
	       return graph1;
        Graph * res = new MBinGraph( (*(MBinGraph*)g1) * 
				         (*(MBinGraph*)g2));
	return wrapGraph(res);
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Graph_Methods() 
{
        STk_add_new_cpp_primitive("mbingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MBinGraphCmd);
        STk_add_new_cpp_primitive("mubingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MUBinGraphCmd);
        STk_add_new_cpp_primitive("mdbingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MDBinGraphCmd);
        STk_add_new_cpp_primitive("bingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))BinGraphCmd);
        STk_add_new_cpp_primitive("ubingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))UBinGraphCmd);
        STk_add_new_cpp_primitive("dbingraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))DBinGraphCmd);
        STk_add_new_cpp_primitive("mhypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MHyperGraphCmd);
        STk_add_new_cpp_primitive("muhypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MUHyperGraphCmd);
        STk_add_new_cpp_primitive("mdhypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))MDHyperGraphCmd);
        STk_add_new_cpp_primitive("hypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))HyperGraphCmd);
        STk_add_new_cpp_primitive("uhypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))UHyperGraphCmd);
        STk_add_new_cpp_primitive("dhypergraph", tc_subr_0_or_1,
                                    (PRIMITIVE (*)(...))DHyperGraphCmd);

        STk_add_new_cpp_primitive("add-subgraph", tc_subr_2,
                                    (PRIMITIVE (*)(...))AddSubgraphCmd);
        STk_add_new_cpp_primitive("dissolve-subgraph", tc_subr_2,
                                    (PRIMITIVE (*)(...))DissolveSubgraphCmd);
        STk_add_new_cpp_primitive("induced-subgraph", tc_subr_3,
                                    (PRIMITIVE (*)(...))InducedSubgraphCmd);
        STk_add_new_cpp_primitive("copy-graph", tc_subr_2,
                                    (PRIMITIVE (*)(...))CopyGraphCmd);
        STk_add_new_cpp_primitive("multi-graph", tc_subr_2,
                                    (PRIMITIVE (*)(...))MultiGraphCmd);
        STk_add_new_cpp_primitive("simple-graph", tc_subr_2,
                                    (PRIMITIVE (*)(...))SimpleGraphCmd);
        STk_add_new_cpp_primitive("make-graph-existing", tc_subr_2,
                                    (PRIMITIVE (*)(...))MakeGraphExistingCmd);
        STk_add_new_cpp_primitive("make-graph-verts-edges", tc_subr_2,
                                    (PRIMITIVE (*)(...))MakeGraphVertsEdgesCmd);
        STk_add_new_cpp_primitive("make-graph-from-scratch", tc_lsubr,
                                    (PRIMITIVE(*)(...))MakeGraphFromScratchCmd);
        STk_add_new_cpp_primitive("make-digraph", tc_subr_0,
                                  (PRIMITIVE (*)(...))MakeDigraphCmd);
        STk_add_new_cpp_primitive("make-digraph-existing", tc_subr_2,
                                  (PRIMITIVE (*)(...))MakeDigraphExistingCmd);
        STk_add_new_cpp_primitive("make-digraph-from-scratch", tc_lsubr,
                                  (PRIMITIVE(*)(...))MakeDigraphFromScratchCmd);
        STk_add_new_cpp_primitive("load-graph", tc_subr_1,
                                  (PRIMITIVE(*)(...))LoadGraphCmd);
        STk_add_new_cpp_primitive("load-dimacs-graph", tc_subr_1,
                                  (PRIMITIVE(*)(...))LoadDimacsGraphCmd);
        STk_add_new_cpp_primitive("save-graph", tc_subr_2,
                                  (PRIMITIVE(*)(...))SaveGraphCmd);
        STk_add_new_cpp_primitive("save-dimacs-graph", tc_subr_2,
                                  (PRIMITIVE(*)(...))SaveDimacsGraphCmd);
        STk_add_new_cpp_primitive("add-graph-edges!", tc_subr_2,
                                    (PRIMITIVE (*)(...))addGraphEdgesCmd);
        STk_add_new_cpp_primitive("add-graph-edge-list!", tc_subr_2,
                                    (PRIMITIVE (*)(...))AddEdgesFromScratchCmd);
        STk_add_new_cpp_primitive("remove-graph-edges!", tc_subr_2,
                                    (PRIMITIVE (*)(...))deleteGraphEdgesCmd);
        STk_add_new_cpp_primitive("remove-graph-edge-list!", tc_subr_2,
                                 (PRIMITIVE (*)(...))DeleteEdgesFromScratchCmd);
        STk_add_new_cpp_primitive("find-vertex-by-name", tc_subr_2,
                                    (PRIMITIVE (*)(...))FindVertexByNameCmd);
        STk_add_new_cpp_primitive("find-edge-by-name", tc_subr_2,
                                    (PRIMITIVE (*)(...))FindEdgeByNameCmd);
        STk_add_new_cpp_primitive("vertex-label", tc_subr_1,
                                    (PRIMITIVE (*)(...))NameGraphObjectCmd);
        STk_add_new_cpp_primitive("edge-label", tc_subr_1,
                                    (PRIMITIVE (*)(...))NameGraphObjectCmd);
        STk_add_new_cpp_primitive("graph-label", tc_subr_1,
                                    (PRIMITIVE (*)(...))NameGraphObjectCmd);
        STk_add_new_cpp_primitive("make-graph-edges", tc_subr_1,
                                    (PRIMITIVE (*)(...))MakeGraphEdgesIntCmd);
        STk_add_new_cpp_primitive("edge-set", tc_subr_1,
                                    (PRIMITIVE (*)(...))EdgeSetGraphCmd);
        STk_add_new_cpp_primitive("vertex-set", tc_subr_1,
                                    (PRIMITIVE (*)(...))VertexSetGraphCmd);
        STk_add_new_cpp_primitive("vertex-vector", tc_subr_1,
                                    (PRIMITIVE (*)(...))VertexVectorGraphCmd);
        STk_add_new_cpp_primitive("add-vertex!", tc_subr_2,
                                    (PRIMITIVE (*)(...))AddVertexGraphCmd);
        STk_add_new_cpp_primitive("remove-vertex!", tc_subr_2,
                                    (PRIMITIVE (*)(...))DeleteVertexGraphCmd);
        STk_add_new_cpp_primitive("remove-vertex2!", tc_subr_2,
                                    (PRIMITIVE (*)(...))DeleteVertex2GraphCmd);
        STk_add_new_cpp_primitive("add-vertices!", tc_subr_3,
                                    (PRIMITIVE (*)(...))AddVerticesGraphCmd);
        STk_add_new_cpp_primitive("remove-vertices!", tc_subr_3,
                                    (PRIMITIVE (*)(...))DeleteVerticesGraphCmd);
        STk_add_new_cpp_primitive("add-edge!", tc_subr_2,
                                    (PRIMITIVE (*)(...))AddEdgeGraphCmd);
        STk_add_new_cpp_primitive("remove-edge!", tc_subr_2,
                                    (PRIMITIVE (*)(...))DeleteEdgeGraphCmd);
        STk_add_new_cpp_primitive("adjacent?", tc_subr_3,
                                    (PRIMITIVE (*)(...))AdjacentQCmd);
        STk_add_new_cpp_primitive("isomorphic?", tc_subr_2,
                                    (PRIMITIVE (*)(...))IsomorphicQCmd);
        STk_add_new_cpp_primitive("is-edge", tc_subr_3,
                                    (PRIMITIVE (*)(...))IsEdgeCmd);
        STk_add_new_cpp_primitive("is-edge2", tc_subr_2,
                                    (PRIMITIVE (*)(...))IsEdgeCmd2);
        STk_add_new_cpp_primitive("incident-edges", tc_subr_1,
                                    (PRIMITIVE (*)(...))IncidentEdgesCmd);
        STk_add_new_cpp_primitive("in-incident-edges", tc_subr_1,
                                    (PRIMITIVE (*)(...))InIncidentEdgesCmd);
        STk_add_new_cpp_primitive("out-incident-edges", tc_subr_1,
                                    (PRIMITIVE (*)(...))OutIncidentEdgesCmd);
        STk_add_new_cpp_primitive("vertex-degree", tc_subr_1,
                                    (PRIMITIVE (*)(...))DegreeCmd);
        STk_add_new_cpp_primitive("vertex-in-degree", tc_subr_1,
                                    (PRIMITIVE (*)(...))InDegreeCmd);
        STk_add_new_cpp_primitive("vertex-out-degree", tc_subr_1,
                                    (PRIMITIVE (*)(...))OutDegreeCmd);
        STk_add_new_cpp_primitive("order", tc_subr_1,
                                    (PRIMITIVE (*)(...))OrderCmd);
        STk_add_new_cpp_primitive("graph-size", tc_subr_1,
                                    (PRIMITIVE (*)(...))SizeCmd);
        STk_add_new_cpp_primitive("vertex-ref", tc_subr_2,
                                    (PRIMITIVE (*)(...))VertexRefCmd);
        STk_add_new_cpp_primitive("vertex-rank", tc_subr_2,
                                    (PRIMITIVE (*)(...))VertexRankCmd);
        STk_add_new_cpp_primitive("edge-ref", tc_subr_2,
                                    (PRIMITIVE (*)(...))EdgeRefCmd);
        STk_add_new_cpp_primitive("edge-rank", tc_subr_2,
                                    (PRIMITIVE (*)(...))EdgeRankCmd);
        STk_add_new_cpp_primitive("complement", tc_subr_1,
                                    (PRIMITIVE (*)(...))GraphComplementCmd);
        STk_add_new_cpp_primitive("line-graph", tc_subr_1,
                                    (PRIMITIVE (*)(...))LineGraphCmd);
        STk_add_new_cpp_primitive("sum", tc_subr_1_or_2,
                                    (PRIMITIVE (*)(...))GraphSumCmd);
        STk_add_new_cpp_primitive("product", tc_subr_1_or_2,
                                    (PRIMITIVE (*)(...))GraphProductCmd);


        addZeroArgMethod("graph", "make-graph", LINK_NEW);

        addOneArgMethod("graph", Wrapper<MSet<Set<int*> > >::name,
                                "make-graph-edges", LINK_OVL);
        addTwoArgMethod("graph", 
				Wrapper<MSet<Vertex*> >::name,
				Wrapper<MSet<Set<Vertex*> > >::name,
                                "make-graph-existing", LINK_OVL);
        addTwoArgMethod("graph", 
				Wrapper<MSet<Vertex*> >::name,
				Wrapper<MSet<Edge*> >::name,
                                "make-graph-verts-edges", LINK_OVL);
        addTwoArgMethod("graph", 
				"<pair>",
				"<pair>",
                                "make-graph-from-scratch", LINK_OVL);

        addZeroArgMethod("digraph", "make-digraph", LINK_NEW);

        addTwoArgMethod("digraph", 
				Wrapper<MSet<Vertex*> >::name,
				Wrapper<MSet<Sequence<Vertex*> > >::name,
                                "make-digraph-existing", LINK_OVL);
        addTwoArgMethod("digraph", 
				"<pair>",
				"<pair>",
                                "make-digraph-from-scratch", LINK_OVL);

        addOneArgMethod("size", Wrapper<Graph*>::name,
                                "graph-size", LINK_NEW);

        addOneArgMethod("degree", Wrapper<Vertex*>::name,
                                "vertex-degree", LINK_NEW);

        addOneArgMethod("in-degree", Wrapper<Vertex*>::name,
                                "vertex-in-degree", LINK_NEW);

        addOneArgMethod("out-degree", Wrapper<Vertex*>::name,
                                "vertex-out-degree", LINK_NEW);

        addTwoArgMethod("find-vertex", 
				"<string>",
				Wrapper<Graph*>::name,
				"find-vertex-by-name", LINK_NEW);

        addTwoArgMethod("find-vertex", 
				"<symbol>",
				Wrapper<Graph*>::name,
				"find-vertex-by-name", LINK_NEW);

        addTwoArgMethod("find-edge", 
				"<string>",
				Wrapper<Graph*>::name,
				"find-edge-by-name", LINK_NEW);

        addTwoArgMethod("find-edge", 
				"<symbol>",
				Wrapper<Graph*>::name,
				"find-edge-by-name", LINK_NEW);
        addTwoArgMethod("add-edges!", 
				"<pair>",
				Wrapper<Graph*>::name,
                                "add-graph-edge-list!", LINK_NEW);
        addTwoArgMethod("add-edges!", 
				Wrapper<MSet<Set<Vertex*> > >::name,
				Wrapper<Graph*>::name,
                                "add-graph-edges!", LINK_OVL);
        addTwoArgMethod("add-edges!", 
				Wrapper<MSet<Sequence<Vertex*> > >::name,
				Wrapper<Graph*>::name,
                                "add-graph-edges!", LINK_OVL);
        addTwoArgMethod("remove-edges!", 
				"<pair>",
				Wrapper<Graph*>::name,
                                "remove-graph-edge-list!", LINK_NEW);
        addTwoArgMethod("remove-edges!", 
				Wrapper<MSet<Set<Vertex*> > >::name,
				Wrapper<Graph*>::name,
                                "remove-graph-edges!", LINK_OVL);
        addTwoArgMethod("remove-edges!", 
				Wrapper<MSet<Sequence<Vertex*> > >::name,
				Wrapper<Graph*>::name,
                                "remove-graph-edges!", LINK_OVL);
        addTwoArgMethod("remove-vertex!", 
				Wrapper<Vertex*>::name,
				Wrapper<Graph*>::name,
                                "remove-vertex2!", LINK_OVL);
        addOneArgMethod("vertices", Wrapper<Graph*>::name,
                                "vertex-set", LINK_NEW);
        addOneArgMethod("edges", Wrapper<Graph*>::name,
                                "edge-set", LINK_NEW);
        addArbMethod("+", Wrapper<Graph*>::name,
                                "sum", LINK_OVL);
        addArbMethod("*", Wrapper<Graph*>::name,
                                "product", LINK_OVL);
}
//genMethods "-g" "-t" "AttributeBase*" "-h" "List" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef List<AttributeBase* > _List_AttributeBase__;

#define _List_AttributeBase__DATA(x) ((List<AttributeBase* >*) (EXTDATA(x)))
#define _List_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<AttributeBase* > >::type))
#define _List_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _List_AttributeBase__CXX_DATA(x) (*(List<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _List_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<AttributeBase* > >::type))
#define _List_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "List" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Edge* _Edge_;
typedef List<Edge* > _List_Edge__;

#define _List_Edge__DATA(x) ((List<Edge* >*) (EXTDATA(x)))
#define _List_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Edge* > >::type))
#define _List_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _List_Edge__CXX_DATA(x) (*(List<Edge* >*) (EXTDATA(VAL(x))))
#define _List_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Edge* > >::type))
#define _List_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "List" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Graph* _Graph_;
typedef List<Graph* > _List_Graph__;

#define _List_Graph__DATA(x) ((List<Graph* >*) (EXTDATA(x)))
#define _List_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Graph* > >::type))
#define _List_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _List_Graph__CXX_DATA(x) (*(List<Graph* >*) (EXTDATA(VAL(x))))
#define _List_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Graph* > >::type))
#define _List_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "List" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/List.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef List<Sequence<Vertex*> > _List_Sequence_Vertex___;

#define _List_Sequence_Vertex___DATA(x) ((List<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _List_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Sequence<Vertex*> > >::type))
#define _List_Sequence_Vertex___ISNT_DATA(x) (!_List_Sequence_Vertex___IS_DATA(x))

#define _List_Sequence_Vertex___CXX_DATA(x) (*(List<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _List_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Sequence<Vertex*> > >::type))
#define _List_Sequence_Vertex___CXX_ISNT_DATA(x) (!_List_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "List" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef List<Set<Vertex*> > _List_Set_Vertex___;

#define _List_Set_Vertex___DATA(x) ((List<Set<Vertex*> >*) (EXTDATA(x)))
#define _List_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<Vertex*> > >::type))
#define _List_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _List_Set_Vertex___CXX_DATA(x) (*(List<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _List_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Set<Vertex*> > >::type))
#define _List_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "List" "-I" "LINK/basic/Subset.h" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef List<SubSet<Vertex*> > _List_SubSet_Vertex___;

#define _List_SubSet_Vertex___DATA(x) ((List<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _List_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<SubSet<Vertex*> > >::type))
#define _List_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _List_SubSet_Vertex___CXX_DATA(x) (*(List<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _List_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<SubSet<Vertex*> > >::type))
#define _List_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "List" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Vertex* _Vertex_;
typedef List<Vertex* > _List_Vertex__;

#define _List_Vertex__DATA(x) ((List<Vertex* >*) (EXTDATA(x)))
#define _List_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Vertex* > >::type))
#define _List_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _List_Vertex__CXX_DATA(x) (*(List<Vertex* >*) (EXTDATA(VAL(x))))
#define _List_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<List<Vertex* > >::type))
#define _List_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_List_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase*" "-h" "MSet" "-r" "Collection<AttributeBase*>" "-I" "LINK/basic/MSet.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef MSet<AttributeBase* > _MSet_AttributeBase__;

#define _MSet_AttributeBase__DATA(x) ((MSet<AttributeBase* >*) (EXTDATA(x)))
#define _MSet_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<AttributeBase* > >::type))
#define _MSet_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_AttributeBase__CXX_DATA(x) (*(MSet<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _MSet_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<AttributeBase* > >::type))
#define _MSet_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "MSet" "-r" "Collection<Edge*>" "-I" "LINK/basic/MSet.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Edge* _Edge_;
typedef MSet<Edge* > _MSet_Edge__;

#define _MSet_Edge__DATA(x) ((MSet<Edge* >*) (EXTDATA(x)))
#define _MSet_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Edge* > >::type))
#define _MSet_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Edge__CXX_DATA(x) (*(MSet<Edge* >*) (EXTDATA(VAL(x))))
#define _MSet_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Edge* > >::type))
#define _MSet_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "MSet" "-r" "Collection<Graph*>" "-I" "LINK/basic/MSet.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Graph* _Graph_;
typedef MSet<Graph* > _MSet_Graph__;

#define _MSet_Graph__DATA(x) ((MSet<Graph* >*) (EXTDATA(x)))
#define _MSet_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Graph* > >::type))
#define _MSet_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Graph__CXX_DATA(x) (*(MSet<Graph* >*) (EXTDATA(VAL(x))))
#define _MSet_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Graph* > >::type))
#define _MSet_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "MSet" "-r" "Collection<Sequence<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef MSet<Sequence<Vertex*> > _MSet_Sequence_Vertex___;

#define _MSet_Sequence_Vertex___DATA(x) ((MSet<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _MSet_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Sequence<Vertex*> > >::type))
#define _MSet_Sequence_Vertex___ISNT_DATA(x) (!_MSet_Sequence_Vertex___IS_DATA(x))

#define _MSet_Sequence_Vertex___CXX_DATA(x) (*(MSet<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _MSet_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Sequence<Vertex*> > >::type))
#define _MSet_Sequence_Vertex___CXX_ISNT_DATA(x) (!_MSet_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "MSet" "-r" "Collection<Set<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef MSet<Set<Vertex*> > _MSet_Set_Vertex___;

#define _MSet_Set_Vertex___DATA(x) ((MSet<Set<Vertex*> >*) (EXTDATA(x)))
#define _MSet_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<Vertex*> > >::type))
#define _MSet_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Set_Vertex___CXX_DATA(x) (*(MSet<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _MSet_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Set<Vertex*> > >::type))
#define _MSet_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "MSet" "-r" "Collection<SubSet<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef MSet<SubSet<Vertex*> > _MSet_SubSet_Vertex___;

#define _MSet_SubSet_Vertex___DATA(x) ((MSet<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _MSet_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<SubSet<Vertex*> > >::type))
#define _MSet_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_SubSet_Vertex___CXX_DATA(x) (*(MSet<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _MSet_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<SubSet<Vertex*> > >::type))
#define _MSet_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "MSet" "-r" "Collection<Vertex*>" "-I" "LINK/basic/MSet.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/MSet.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Vertex* _Vertex_;
typedef MSet<Vertex* > _MSet_Vertex__;

#define _MSet_Vertex__DATA(x) ((MSet<Vertex* >*) (EXTDATA(x)))
#define _MSet_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Vertex* > >::type))
#define _MSet_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _MSet_Vertex__CXX_DATA(x) (*(MSet<Vertex* >*) (EXTDATA(VAL(x))))
#define _MSet_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MSet<Vertex* > >::type))
#define _MSet_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_MSet_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase*" "-h" "Sequence" "-r" "Collection<AttributeBase*>" "-I" "LINK/basic/Sequence.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef Sequence<AttributeBase* > _Sequence_AttributeBase__;

#define _Sequence_AttributeBase__DATA(x) ((Sequence<AttributeBase* >*) (EXTDATA(x)))
#define _Sequence_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<AttributeBase* > >::type))
#define _Sequence_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_AttributeBase__CXX_DATA(x) (*(Sequence<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _Sequence_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<AttributeBase* > >::type))
#define _Sequence_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "Sequence" "-r" "Collection<Edge*>" "-I" "LINK/basic/Sequence.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Edge* _Edge_;
typedef Sequence<Edge* > _Sequence_Edge__;

#define _Sequence_Edge__DATA(x) ((Sequence<Edge* >*) (EXTDATA(x)))
#define _Sequence_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Edge* > >::type))
#define _Sequence_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Edge__CXX_DATA(x) (*(Sequence<Edge* >*) (EXTDATA(VAL(x))))
#define _Sequence_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Edge* > >::type))
#define _Sequence_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "Sequence" "-r" "Collection<Graph*>" "-I" "LINK/basic/Sequence.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Graph* _Graph_;
typedef Sequence<Graph* > _Sequence_Graph__;

#define _Sequence_Graph__DATA(x) ((Sequence<Graph* >*) (EXTDATA(x)))
#define _Sequence_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Graph* > >::type))
#define _Sequence_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Graph__CXX_DATA(x) (*(Sequence<Graph* >*) (EXTDATA(VAL(x))))
#define _Sequence_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Graph* > >::type))
#define _Sequence_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "Sequence" "-r" "Collection<Sequence<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef Sequence<Sequence<Vertex*> > _Sequence_Sequence_Vertex___;

#define _Sequence_Sequence_Vertex___DATA(x) ((Sequence<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _Sequence_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Sequence<Vertex*> > >::type))
#define _Sequence_Sequence_Vertex___ISNT_DATA(x) (!_Sequence_Sequence_Vertex___IS_DATA(x))

#define _Sequence_Sequence_Vertex___CXX_DATA(x) (*(Sequence<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Sequence_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Sequence<Vertex*> > >::type))
#define _Sequence_Sequence_Vertex___CXX_ISNT_DATA(x) (!_Sequence_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "Sequence" "-r" "Collection<Set<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef Sequence<Set<Vertex*> > _Sequence_Set_Vertex___;

#define _Sequence_Set_Vertex___DATA(x) ((Sequence<Set<Vertex*> >*) (EXTDATA(x)))
#define _Sequence_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<Vertex*> > >::type))
#define _Sequence_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Set_Vertex___CXX_DATA(x) (*(Sequence<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Sequence_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Set<Vertex*> > >::type))
#define _Sequence_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "Sequence" "-r" "Collection<SubSet<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef Sequence<SubSet<Vertex*> > _Sequence_SubSet_Vertex___;

#define _Sequence_SubSet_Vertex___DATA(x) ((Sequence<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _Sequence_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<SubSet<Vertex*> > >::type))
#define _Sequence_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_SubSet_Vertex___CXX_DATA(x) (*(Sequence<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Sequence_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<SubSet<Vertex*> > >::type))
#define _Sequence_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "Sequence" "-r" "Collection<Vertex*>" "-I" "LINK/basic/Sequence.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Sequence.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Vertex* _Vertex_;
typedef Sequence<Vertex* > _Sequence_Vertex__;

#define _Sequence_Vertex__DATA(x) ((Sequence<Vertex* >*) (EXTDATA(x)))
#define _Sequence_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Vertex* > >::type))
#define _Sequence_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _Sequence_Vertex__CXX_DATA(x) (*(Sequence<Vertex* >*) (EXTDATA(VAL(x))))
#define _Sequence_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Sequence<Vertex* > >::type))
#define _Sequence_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Sequence_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase*" "-h" "Set" "-r" "MSet<AttributeBase*>" "-I" "LINK/basic/Set.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef Set<AttributeBase* > _Set_AttributeBase__;

#define _Set_AttributeBase__DATA(x) ((Set<AttributeBase* >*) (EXTDATA(x)))
#define _Set_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<AttributeBase* > >::type))
#define _Set_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_AttributeBase__CXX_DATA(x) (*(Set<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _Set_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<AttributeBase* > >::type))
#define _Set_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "Set" "-r" "MSet<Edge*>" "-I" "LINK/basic/Set.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Edge* _Edge_;
typedef Set<Edge* > _Set_Edge__;

#define _Set_Edge__DATA(x) ((Set<Edge* >*) (EXTDATA(x)))
#define _Set_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Edge* > >::type))
#define _Set_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Edge__CXX_DATA(x) (*(Set<Edge* >*) (EXTDATA(VAL(x))))
#define _Set_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Edge* > >::type))
#define _Set_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "Set" "-r" "MSet<Graph*>" "-I" "LINK/basic/Set.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Graph* _Graph_;
typedef Set<Graph* > _Set_Graph__;

#define _Set_Graph__DATA(x) ((Set<Graph* >*) (EXTDATA(x)))
#define _Set_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Graph* > >::type))
#define _Set_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Graph__CXX_DATA(x) (*(Set<Graph* >*) (EXTDATA(VAL(x))))
#define _Set_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Graph* > >::type))
#define _Set_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "Set" "-r" "MSet<Sequence<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef Set<Sequence<Vertex*> > _Set_Sequence_Vertex___;

#define _Set_Sequence_Vertex___DATA(x) ((Set<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _Set_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Sequence<Vertex*> > >::type))
#define _Set_Sequence_Vertex___ISNT_DATA(x) (!_Set_Sequence_Vertex___IS_DATA(x))

#define _Set_Sequence_Vertex___CXX_DATA(x) (*(Set<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Set_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Sequence<Vertex*> > >::type))
#define _Set_Sequence_Vertex___CXX_ISNT_DATA(x) (!_Set_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "Set" "-r" "MSet<Set<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef Set<Set<Vertex*> > _Set_Set_Vertex___;

#define _Set_Set_Vertex___DATA(x) ((Set<Set<Vertex*> >*) (EXTDATA(x)))
#define _Set_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<Vertex*> > >::type))
#define _Set_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Set_Vertex___CXX_DATA(x) (*(Set<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Set_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Set<Vertex*> > >::type))
#define _Set_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "Set" "-r" "MSet<SubSet<Vertex*> >" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Subset.h" "-I" "LINK/basic/Set.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Subset.h>

#include <LINK/basic/Set.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef Set<SubSet<Vertex*> > _Set_SubSet_Vertex___;

#define _Set_SubSet_Vertex___DATA(x) ((Set<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _Set_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<SubSet<Vertex*> > >::type))
#define _Set_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _Set_SubSet_Vertex___CXX_DATA(x) (*(Set<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _Set_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<SubSet<Vertex*> > >::type))
#define _Set_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "Set" "-r" "MSet<Vertex*>" "-I" "LINK/basic/Set.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Set.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/CollectionWrapper.h>


typedef Vertex* _Vertex_;
typedef Set<Vertex* > _Set_Vertex__;

#define _Set_Vertex__DATA(x) ((Set<Vertex* >*) (EXTDATA(x)))
#define _Set_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Vertex* > >::type))
#define _Set_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _Set_Vertex__CXX_DATA(x) (*(Set<Vertex* >*) (EXTDATA(VAL(x))))
#define _Set_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Set<Vertex* > >::type))
#define _Set_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Set_Vertex__Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "SortedArray" "-r" "Array<Vertex*>" "-I" "LINK/basic/Array.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Array.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ArrayWrapper.h>


typedef Vertex* _Vertex_;
typedef SortedArray<Vertex* > _SortedArray_Vertex__;

#define _SortedArray_Vertex__DATA(x) ((SortedArray<Vertex* >*) (EXTDATA(x)))
#define _SortedArray_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<Vertex* > >::type))
#define _SortedArray_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedArray_Vertex__CXX_DATA(x) (*(SortedArray<Vertex* >*) (EXTDATA(VAL(x))))
#define _SortedArray_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedArray<Vertex* > >::type))
#define _SortedArray_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedArray_Vertex__Methods() {}

//genMethods "-g" "-t" "AttributeBase*" "-h" "SortedList" "-r" "List<AttributeBase*>" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Attribute.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Attribute.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef AttributeBase* _AttributeBase_;
typedef SortedList<AttributeBase* > _SortedList_AttributeBase__;

#define _SortedList_AttributeBase__DATA(x) ((SortedList<AttributeBase* >*) (EXTDATA(x)))
#define _SortedList_AttributeBase__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<AttributeBase* > >::type))
#define _SortedList_AttributeBase__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_AttributeBase__CXX_DATA(x) (*(SortedList<AttributeBase* >*) (EXTDATA(VAL(x))))
#define _SortedList_AttributeBase__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<AttributeBase* > >::type))
#define _SortedList_AttributeBase__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_AttributeBase__Methods() {}

//genMethods "-g" "-t" "Edge*" "-h" "SortedList" "-r" "List<Edge*>" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Edge.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Edge.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Edge* _Edge_;
typedef SortedList<Edge* > _SortedList_Edge__;

#define _SortedList_Edge__DATA(x) ((SortedList<Edge* >*) (EXTDATA(x)))
#define _SortedList_Edge__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Edge* > >::type))
#define _SortedList_Edge__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Edge__CXX_DATA(x) (*(SortedList<Edge* >*) (EXTDATA(VAL(x))))
#define _SortedList_Edge__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Edge* > >::type))
#define _SortedList_Edge__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Edge__Methods() {}

//genMethods "-g" "-t" "Graph*" "-h" "SortedList" "-r" "List<Graph*>" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Graph.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Graph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Graph* _Graph_;
typedef SortedList<Graph* > _SortedList_Graph__;

#define _SortedList_Graph__DATA(x) ((SortedList<Graph* >*) (EXTDATA(x)))
#define _SortedList_Graph__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Graph* > >::type))
#define _SortedList_Graph__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Graph__CXX_DATA(x) (*(SortedList<Graph* >*) (EXTDATA(VAL(x))))
#define _SortedList_Graph__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Graph* > >::type))
#define _SortedList_Graph__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Graph__Methods() {}

//genMethods "-g" "-t" "Sequence<Vertex*>" "-h" "SortedList" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Sequence.h" "-I" "LINK/basic/List.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Sequence<Vertex*> _Sequence_Vertex__;
typedef SortedList<Sequence<Vertex*> > _SortedList_Sequence_Vertex___;

#define _SortedList_Sequence_Vertex___DATA(x) ((SortedList<Sequence<Vertex*> >*) (EXTDATA(x)))
#define _SortedList_Sequence_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Sequence<Vertex*> > >::type))
#define _SortedList_Sequence_Vertex___ISNT_DATA(x) (!_SortedList_Sequence_Vertex___IS_DATA(x))

#define _SortedList_Sequence_Vertex___CXX_DATA(x) (*(SortedList<Sequence<Vertex*> >*) (EXTDATA(VAL(x))))
#define _SortedList_Sequence_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Sequence<Vertex*> > >::type))
#define _SortedList_Sequence_Vertex___CXX_ISNT_DATA(x) (!_SortedList_Sequence_Vertex___CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Sequence_Vertex___Methods() {}
//genMethods "-g" "-t" "Set<Vertex*>" "-h" "SortedList" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Set<Vertex*> _Set_Vertex__;
typedef SortedList<Set<Vertex*> > _SortedList_Set_Vertex___;

#define _SortedList_Set_Vertex___DATA(x) ((SortedList<Set<Vertex*> >*) (EXTDATA(x)))
#define _SortedList_Set_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<Vertex*> > >::type))
#define _SortedList_Set_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Set_Vertex___CXX_DATA(x) (*(SortedList<Set<Vertex*> >*) (EXTDATA(VAL(x))))
#define _SortedList_Set_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Set<Vertex*> > >::type))
#define _SortedList_Set_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Set_Vertex___Methods() {}

//genMethods "-t" "SubSet<Vertex*>" "-h" "SortedList" "-I" "LINK/basic/Subset.h" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Set.h" "-I" "LINK/basic/List.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/Subset.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/List.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef SubSet<Vertex*> _SubSet_Vertex__;
typedef SortedList<SubSet<Vertex*> > _SortedList_SubSet_Vertex___;

#define _SortedList_SubSet_Vertex___DATA(x) ((SortedList<SubSet<Vertex*> >*) (EXTDATA(x)))
#define _SortedList_SubSet_Vertex___IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<SubSet<Vertex*> > >::type))
#define _SortedList_SubSet_Vertex___ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_SubSet_Vertex___CXX_DATA(x) (*(SortedList<SubSet<Vertex*> >*) (EXTDATA(VAL(x))))
#define _SortedList_SubSet_Vertex___CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<SubSet<Vertex*> > >::type))
#define _SortedList_SubSet_Vertex___CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_SubSet_Vertex___Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "SortedList" "-r" "List<Vertex*>" "-I" "LINK/basic/List.h" "-I" "LINK/graph/Vertex.h" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/basic/List.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>
#include <LINK/stkWrapper/ListWrapper.h>


typedef Vertex* _Vertex_;
typedef SortedList<Vertex* > _SortedList_Vertex__;

#define _SortedList_Vertex__DATA(x) ((SortedList<Vertex* >*) (EXTDATA(x)))
#define _SortedList_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Vertex* > >::type))
#define _SortedList_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _SortedList_Vertex__CXX_DATA(x) (*(SortedList<Vertex* >*) (EXTDATA(VAL(x))))
#define _SortedList_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SortedList<Vertex* > >::type))
#define _SortedList_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SortedList_Vertex__Methods() {}

//genMethods "-g" "-t" "Vertex*" "-h" "SubSet" "-I" "LINK/graph/Vertex.h" "-I" "LINK/basic/Subset.h" "-y" "display_subset_vertex" "-d" "graph" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/basic/Subset.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_subset_vertex(SCM, SCM, int);

typedef Vertex* _Vertex_;
typedef SubSet<Vertex* > _SubSet_Vertex__;

#define _SubSet_Vertex__DATA(x) ((SubSet<Vertex* >*) (EXTDATA(x)))
#define _SubSet_Vertex__IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SubSet<Vertex* > >::type))
#define _SubSet_Vertex__ISNT_DATA(x) (!IS_DATA(x))

#define _SubSet_Vertex__CXX_DATA(x) (*(SubSet<Vertex* >*) (EXTDATA(VAL(x))))
#define _SubSet_Vertex__CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<SubSet<Vertex* > >::type))
#define _SubSet_Vertex__CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include<strstream.h>
void display_subset_vertex(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (_SubSet_Vertex__DATA(c))		
        	oss << *_SubSet_Vertex__DATA(c);
        oss << ends;				
        char *buffer = oss.str();		
        Puts(buffer, FILEPTR(port));		
        delete buffer;
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_SubSet_Vertex__Methods() {}

//genMethods "-g" "-t" "Vertex" "-I" "LINK/graph/Vertex.h" "-d" "graph" "-y" "display_vertex" "-w" "free_vertex" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_vertex(SCM, SCM, int);
void free_vertex(SCM);

typedef Vertex _Vertex;

#define _VertexDATA(x) ((Vertex*) (EXTDATA(x)))
#define _VertexIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Vertex >::type))
#define _VertexISNT_DATA(x) (!IS_DATA(x))

#define _VertexCXX_DATA(x) (*(Vertex*) (EXTDATA(VAL(x))))
#define _VertexCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Vertex >::type))
#define _VertexCXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include <strstream.h>
void display_vertex(SCM c, SCM port, int mode)
{
        ostrstream oss;
	if (_VertexDATA(c))
        	oss << *_VertexDATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void free_vertex(SCM p)
{
        if (!EXTSTATICP(p))
                Register<Vertex>::deleteEntry(_VertexDATA(p));
}

// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_VertexMethods() {}

//genMethods "-g" "-t" "Vertex*" "-I" "LINK/graph/Vertex.h" "-d" "graph" "-y" "display_vertexptr" "-m" "mark_vertexptr" "-w" "free_vertexptr" 

#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Vertex.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_vertexptr(SCM, SCM, int);
void mark_vertexptr(SCM);
void free_vertexptr(SCM);

typedef Vertex* _Vertex_;

#define _Vertex_DATA(x) ((Vertex**) (EXTDATA(x)))
#define _Vertex_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Vertex* >::type))
#define _Vertex_ISNT_DATA(x) (!IS_DATA(x))

#define _Vertex_CXX_DATA(x) (*(Vertex**) (EXTDATA(VAL(x))))
#define _Vertex_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<Vertex* >::type))
#define _Vertex_CXX_ISNT_DATA(x) (!CXX_IS_DATA(x))

#include <strstream.h>
void display_vertexptr(SCM c, SCM port, int mode)
{
        ostrstream oss;
        if (*_Vertex_DATA(c))
        	oss << **_Vertex_DATA(c);
        oss << ends;
        char *buffer = oss.str();
        Puts(buffer, FILEPTR(port));
        delete buffer;
}

void mark_vertexptr(SCM p)
{
        Register<Vertex>::markEntry(*_Vertex_DATA(p));
}

void free_vertexptr(SCM p)
{
        if (!EXTSTATICP(p)) {
                delete _Vertex_DATA(p);
        }
}


static PRIMITIVE InNeighborsVertexCmd(SCM v)
{
        Vertex *vert;
        int& vtype = Wrapper<Vertex*>::type;
        if (!CXX_TYPEP(v, vtype))
                Err("in-neighbors: bad arg 1, <vertex*> expected", v);
	vert = *(Vertex**) CLASSDATA(v);
        Set<Vertex*>* s = new Set<Vertex*>(vert->inNeighbors());

        //Set<Vertex*>* s = new Set<Vertex*>(gr->vertices());  SEGFAULT (WHY?)

        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE OutNeighborsVertexCmd(SCM v)
{
        Vertex *vert;
        int& vtype = Wrapper<Vertex*>::type;
        if (!CXX_TYPEP(v, vtype))
                Err("out-neighbors: bad arg 1, <vertex*> expected", v);
	vert = *(Vertex**) CLASSDATA(v);
        Set<Vertex*>* s = new Set<Vertex*>(vert->outNeighbors());

        //Set<Vertex*>* s = new Set<Vertex*>(gr->vertices());  SEGFAULT (WHY?)

        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}

static PRIMITIVE NeighborsVertexCmd(SCM v)
{
        Vertex *vert;
        int& vtype = Wrapper<Vertex*>::type;
        if (!CXX_TYPEP(v, vtype))
                Err("neighbors: bad arg 1, <vertex*> expected", v);
	vert = *(Vertex**) CLASSDATA(v);
        Set<Vertex*>* s = new Set<Vertex*>(vert->neighbors());

        //Set<Vertex*>* s = new Set<Vertex*>(gr->vertices());  SEGFAULT (WHY?)

        return STk_make_CXXwrapper(Wrapper<Set<Vertex*> >::type,
                Wrapper<Set<Vertex*> >::name, (void *) s, LINK_DYNAMIC);
}


// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_Vertex_Methods() 
{
        STk_add_new_cpp_primitive("neighbors", tc_subr_1,
                                    (PRIMITIVE (*)(...))NeighborsVertexCmd);
        STk_add_new_cpp_primitive("in-neighbors", tc_subr_1,
                                    (PRIMITIVE (*)(...))InNeighborsVertexCmd);
        STk_add_new_cpp_primitive("out-neighbors", tc_subr_1,
                                    (PRIMITIVE (*)(...))OutNeighborsVertexCmd);
}
//genMethods "-g" "-t" "MHyperGraph" "-r" "Graph" "-I" "LINK/graph/HyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "____mHyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MHyperGraph _MHyperGraph;

#define _MHyperGraphDATA(x) ((MHyperGraph*) (EXTDATA(x)))
#define _MHyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MHyperGraph >::type))
#define _MHyperGraphISNT_DATA(x) (!_MHyperGraphIS_DATA(x))

#define _MHyperGraphCXX_DATA(x) (*(MHyperGraph*) (EXTDATA(VAL(x))))
#define _MHyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MHyperGraph >::type))
#define _MHyperGraphCXX_ISNT_DATA(x) (!_MHyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra____mHyperGraphMethods() {}
//genMethods "-g" "-t" "MHyperGraph*" "-r" "Graph*" "-I" "LINK/graph/HyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "____mHyperGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MHyperGraph* _MHyperGraph_;

#define _MHyperGraph_DATA(x) ((MHyperGraph**) (EXTDATA(x)))
#define _MHyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MHyperGraph* >::type))
#define _MHyperGraph_ISNT_DATA(x) (!_MHyperGraph_IS_DATA(x))

#define _MHyperGraph_CXX_DATA(x) (*(MHyperGraph**) (EXTDATA(VAL(x))))
#define _MHyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MHyperGraph* >::type))
#define _MHyperGraph_CXX_ISNT_DATA(x) (!_MHyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra____mHyperGraph_Methods() {}
//genMethods "-g" "-t" "HyperGraph" "-r" "MHyperGraph" "-I" "LINK/graph/HyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "___hyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef HyperGraph _HyperGraph;

#define _HyperGraphDATA(x) ((HyperGraph*) (EXTDATA(x)))
#define _HyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<HyperGraph >::type))
#define _HyperGraphISNT_DATA(x) (!_HyperGraphIS_DATA(x))

#define _HyperGraphCXX_DATA(x) (*(HyperGraph*) (EXTDATA(VAL(x))))
#define _HyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<HyperGraph >::type))
#define _HyperGraphCXX_ISNT_DATA(x) (!_HyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___hyperGraphMethods() {}
//genMethods "-g" "-t" "HyperGraph*" "-r" "MHyperGraph*" "-I" "LINK/graph/HyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "___hyperGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef HyperGraph* _HyperGraph_;

#define _HyperGraph_DATA(x) ((HyperGraph**) (EXTDATA(x)))
#define _HyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<HyperGraph* >::type))
#define _HyperGraph_ISNT_DATA(x) (!_HyperGraph_IS_DATA(x))

#define _HyperGraph_CXX_DATA(x) (*(HyperGraph**) (EXTDATA(VAL(x))))
#define _HyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<HyperGraph* >::type))
#define _HyperGraph_CXX_ISNT_DATA(x) (!_HyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___hyperGraph_Methods() {}
//genMethods "-g" "-t" "MBinGraph" "-r" "MHyperGraph" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/BinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "___mBinGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/BinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MBinGraph _MBinGraph;

#define _MBinGraphDATA(x) ((MBinGraph*) (EXTDATA(x)))
#define _MBinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MBinGraph >::type))
#define _MBinGraphISNT_DATA(x) (!_MBinGraphIS_DATA(x))

#define _MBinGraphCXX_DATA(x) (*(MBinGraph*) (EXTDATA(VAL(x))))
#define _MBinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MBinGraph >::type))
#define _MBinGraphCXX_ISNT_DATA(x) (!_MBinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mBinGraphMethods() {}
//genMethods "-g" "-t" "MBinGraph*" "-r" "MHyperGraph*" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/BinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "___mBinGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/BinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MBinGraph* _MBinGraph_;

#define _MBinGraph_DATA(x) ((MBinGraph**) (EXTDATA(x)))
#define _MBinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MBinGraph* >::type))
#define _MBinGraph_ISNT_DATA(x) (!_MBinGraph_IS_DATA(x))

#define _MBinGraph_CXX_DATA(x) (*(MBinGraph**) (EXTDATA(VAL(x))))
#define _MBinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MBinGraph* >::type))
#define _MBinGraph_CXX_ISNT_DATA(x) (!_MBinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mBinGraph_Methods() {}
//genMethods "-g" "-t" "MDHyperGraph" "-r" "MHyperGraph" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/DHyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "___mDHyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/DHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MDHyperGraph _MDHyperGraph;

#define _MDHyperGraphDATA(x) ((MDHyperGraph*) (EXTDATA(x)))
#define _MDHyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDHyperGraph >::type))
#define _MDHyperGraphISNT_DATA(x) (!_MDHyperGraphIS_DATA(x))

#define _MDHyperGraphCXX_DATA(x) (*(MDHyperGraph*) (EXTDATA(VAL(x))))
#define _MDHyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDHyperGraph >::type))
#define _MDHyperGraphCXX_ISNT_DATA(x) (!_MDHyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mDHyperGraphMethods() {}
//genMethods "-g" "-t" "MDHyperGraph*" "-r" "MHyperGraph*" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/DHyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "___mDHyperGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/DHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MDHyperGraph* _MDHyperGraph_;

#define _MDHyperGraph_DATA(x) ((MDHyperGraph**) (EXTDATA(x)))
#define _MDHyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDHyperGraph* >::type))
#define _MDHyperGraph_ISNT_DATA(x) (!_MDHyperGraph_IS_DATA(x))

#define _MDHyperGraph_CXX_DATA(x) (*(MDHyperGraph**) (EXTDATA(VAL(x))))
#define _MDHyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDHyperGraph* >::type))
#define _MDHyperGraph_CXX_ISNT_DATA(x) (!_MDHyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mDHyperGraph_Methods() {}
//genMethods "-g" "-t" "MUHyperGraph" "-r" "MHyperGraph" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/UHyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "___mUHyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/UHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MUHyperGraph _MUHyperGraph;

#define _MUHyperGraphDATA(x) ((MUHyperGraph*) (EXTDATA(x)))
#define _MUHyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUHyperGraph >::type))
#define _MUHyperGraphISNT_DATA(x) (!_MUHyperGraphIS_DATA(x))

#define _MUHyperGraphCXX_DATA(x) (*(MUHyperGraph*) (EXTDATA(VAL(x))))
#define _MUHyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUHyperGraph >::type))
#define _MUHyperGraphCXX_ISNT_DATA(x) (!_MUHyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mUHyperGraphMethods() {}
//genMethods "-g" "-t" "MUHyperGraph*" "-r" "MHyperGraph*" "-I" "LINK/graph/HyperGraph.h" "-I" "LINK/graph/UHyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "___mUHyper_Graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/HyperGraph.h>

#include <LINK/graph/UHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MUHyperGraph* _MUHyperGraph_;

#define _MUHyperGraph_DATA(x) ((MUHyperGraph**) (EXTDATA(x)))
#define _MUHyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUHyperGraph* >::type))
#define _MUHyperGraph_ISNT_DATA(x) (!_MUHyperGraph_IS_DATA(x))

#define _MUHyperGraph_CXX_DATA(x) (*(MUHyperGraph**) (EXTDATA(VAL(x))))
#define _MUHyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUHyperGraph* >::type))
#define _MUHyperGraph_CXX_ISNT_DATA(x) (!_MUHyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra___mUHyper_GraphMethods() {}
//genMethods "-g" "-t" "BinGraph" "-r" "MBinGraph" "-I" "LINK/graph/BinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "__binGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/BinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef BinGraph _BinGraph;

#define _BinGraphDATA(x) ((BinGraph*) (EXTDATA(x)))
#define _BinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<BinGraph >::type))
#define _BinGraphISNT_DATA(x) (!_BinGraphIS_DATA(x))

#define _BinGraphCXX_DATA(x) (*(BinGraph*) (EXTDATA(VAL(x))))
#define _BinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<BinGraph >::type))
#define _BinGraphCXX_ISNT_DATA(x) (!_BinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__binGraphMethods() {}
//genMethods "-g" "-t" "BinGraph*" "-r" "MBinGraph*" "-I" "LINK/graph/BinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "__binGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/BinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef BinGraph* _BinGraph_;

#define _BinGraph_DATA(x) ((BinGraph**) (EXTDATA(x)))
#define _BinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<BinGraph* >::type))
#define _BinGraph_ISNT_DATA(x) (!_BinGraph_IS_DATA(x))

#define _BinGraph_CXX_DATA(x) (*(BinGraph**) (EXTDATA(VAL(x))))
#define _BinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<BinGraph* >::type))
#define _BinGraph_CXX_ISNT_DATA(x) (!_BinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__binGraph_Methods() {}
//genMethods "-g" "-t" "DHyperGraph" "-r" "MDHyperGraph" "-I" "LINK/graph/DHyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "__dHyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef DHyperGraph _DHyperGraph;

#define _DHyperGraphDATA(x) ((DHyperGraph*) (EXTDATA(x)))
#define _DHyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DHyperGraph >::type))
#define _DHyperGraphISNT_DATA(x) (!_DHyperGraphIS_DATA(x))

#define _DHyperGraphCXX_DATA(x) (*(DHyperGraph*) (EXTDATA(VAL(x))))
#define _DHyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DHyperGraph >::type))
#define _DHyperGraphCXX_ISNT_DATA(x) (!_DHyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__dHyperGraphMethods() {}
//genMethods "-g" "-t" "DHyperGraph*" "-r" "MDHyperGraph*" "-I" "LINK/graph/DHyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "__dHyperGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef DHyperGraph* _DHyperGraph_;

#define _DHyperGraph_DATA(x) ((DHyperGraph**) (EXTDATA(x)))
#define _DHyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DHyperGraph* >::type))
#define _DHyperGraph_ISNT_DATA(x) (!_DHyperGraph_IS_DATA(x))

#define _DHyperGraph_CXX_DATA(x) (*(DHyperGraph**) (EXTDATA(VAL(x))))
#define _DHyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DHyperGraph* >::type))
#define _DHyperGraph_CXX_ISNT_DATA(x) (!_DHyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__dHyperGraph_Methods() {}
//genMethods "-g" "-t" "MDBinGraph" "-r" "MBinGraph" "-I" "LINK/graph/DBinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "__mDBinGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MDBinGraph _MDBinGraph;

#define _MDBinGraphDATA(x) ((MDBinGraph*) (EXTDATA(x)))
#define _MDBinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDBinGraph >::type))
#define _MDBinGraphISNT_DATA(x) (!_MDBinGraphIS_DATA(x))

#define _MDBinGraphCXX_DATA(x) (*(MDBinGraph*) (EXTDATA(VAL(x))))
#define _MDBinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDBinGraph >::type))
#define _MDBinGraphCXX_ISNT_DATA(x) (!_MDBinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__mDBinGraphMethods() {}
//genMethods "-g" "-t" "MDBinGraph*" "-r" "MBinGraph*" "-I" "LINK/graph/DBinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "__mDBinGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MDBinGraph* _MDBinGraph_;

#define _MDBinGraph_DATA(x) ((MDBinGraph**) (EXTDATA(x)))
#define _MDBinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDBinGraph* >::type))
#define _MDBinGraph_ISNT_DATA(x) (!_MDBinGraph_IS_DATA(x))

#define _MDBinGraph_CXX_DATA(x) (*(MDBinGraph**) (EXTDATA(VAL(x))))
#define _MDBinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MDBinGraph* >::type))
#define _MDBinGraph_CXX_ISNT_DATA(x) (!_MDBinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__mDBinGraph_Methods() {}
//genMethods "-g" "-t" "MUBinGraph" "-r" "MBinGraph" "-I" "LINK/graph/UBinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "__mUBinGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef MUBinGraph _MUBinGraph;

#define _MUBinGraphDATA(x) ((MUBinGraph*) (EXTDATA(x)))
#define _MUBinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUBinGraph >::type))
#define _MUBinGraphISNT_DATA(x) (!_MUBinGraphIS_DATA(x))

#define _MUBinGraphCXX_DATA(x) (*(MUBinGraph*) (EXTDATA(VAL(x))))
#define _MUBinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUBinGraph >::type))
#define _MUBinGraphCXX_ISNT_DATA(x) (!_MUBinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__mUBinGraphMethods() {}
//genMethods "-g" "-t" "MUBinGraph*" "-r" "MBinGraph*" "-I" "LINK/graph/UBinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "__mUBinGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef MUBinGraph* _MUBinGraph_;

#define _MUBinGraph_DATA(x) ((MUBinGraph**) (EXTDATA(x)))
#define _MUBinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUBinGraph* >::type))
#define _MUBinGraph_ISNT_DATA(x) (!_MUBinGraph_IS_DATA(x))

#define _MUBinGraph_CXX_DATA(x) (*(MUBinGraph**) (EXTDATA(VAL(x))))
#define _MUBinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<MUBinGraph* >::type))
#define _MUBinGraph_CXX_ISNT_DATA(x) (!_MUBinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__mUBinGraph_Methods() {}
//genMethods "-g" "-t" "UHyperGraph" "-r" "MUHyperGraph" "-I" "LINK/graph/UHyperGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "__uHyperGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef UHyperGraph _UHyperGraph;

#define _UHyperGraphDATA(x) ((UHyperGraph*) (EXTDATA(x)))
#define _UHyperGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UHyperGraph >::type))
#define _UHyperGraphISNT_DATA(x) (!_UHyperGraphIS_DATA(x))

#define _UHyperGraphCXX_DATA(x) (*(UHyperGraph*) (EXTDATA(VAL(x))))
#define _UHyperGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UHyperGraph >::type))
#define _UHyperGraphCXX_ISNT_DATA(x) (!_UHyperGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__uHyperGraphMethods() {}
//genMethods "-g" "-t" "UHyperGraph*" "-r" "MUHyperGraph*" "-I" "LINK/graph/UHyperGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "__uHyperGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UHyperGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef UHyperGraph* _UHyperGraph_;

#define _UHyperGraph_DATA(x) ((UHyperGraph**) (EXTDATA(x)))
#define _UHyperGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UHyperGraph* >::type))
#define _UHyperGraph_ISNT_DATA(x) (!_UHyperGraph_IS_DATA(x))

#define _UHyperGraph_CXX_DATA(x) (*(UHyperGraph**) (EXTDATA(VAL(x))))
#define _UHyperGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UHyperGraph* >::type))
#define _UHyperGraph_CXX_ISNT_DATA(x) (!_UHyperGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra__uHyperGraph_Methods() {}
//genMethods "-g" "-t" "DBinGraph" "-r" "MDBinGraph" "-I" "LINK/graph/DBinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "_dBinGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef DBinGraph _DBinGraph;

#define _DBinGraphDATA(x) ((DBinGraph*) (EXTDATA(x)))
#define _DBinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DBinGraph >::type))
#define _DBinGraphISNT_DATA(x) (!_DBinGraphIS_DATA(x))

#define _DBinGraphCXX_DATA(x) (*(DBinGraph*) (EXTDATA(VAL(x))))
#define _DBinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DBinGraph >::type))
#define _DBinGraphCXX_ISNT_DATA(x) (!_DBinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_dBinGraphMethods() {}
//genMethods "-g" "-t" "DBinGraph*" "-r" "MDBinGraph*" "-I" "LINK/graph/DBinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "_dBinGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/DBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef DBinGraph* _DBinGraph_;

#define _DBinGraph_DATA(x) ((DBinGraph**) (EXTDATA(x)))
#define _DBinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DBinGraph* >::type))
#define _DBinGraph_ISNT_DATA(x) (!_DBinGraph_IS_DATA(x))

#define _DBinGraph_CXX_DATA(x) (*(DBinGraph**) (EXTDATA(VAL(x))))
#define _DBinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<DBinGraph* >::type))
#define _DBinGraph_CXX_ISNT_DATA(x) (!_DBinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_dBinGraph_Methods() {}
//genMethods "-g" "-t" "UBinGraph" "-r" "MUBinGraph" "-I" "LINK/graph/UBinGraph.h" "-y" "display_graph" "-w" "free_graph" "-d" "graph" "-f" "_uBinGraph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graph(SCM, SCM, int);
void free_graph(SCM);

typedef UBinGraph _UBinGraph;

#define _UBinGraphDATA(x) ((UBinGraph*) (EXTDATA(x)))
#define _UBinGraphIS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UBinGraph >::type))
#define _UBinGraphISNT_DATA(x) (!_UBinGraphIS_DATA(x))

#define _UBinGraphCXX_DATA(x) (*(UBinGraph*) (EXTDATA(VAL(x))))
#define _UBinGraphCXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UBinGraph >::type))
#define _UBinGraphCXX_ISNT_DATA(x) (!_UBinGraphCXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_uBinGraphMethods() {}
//genMethods "-g" "-t" "UBinGraph*" "-r" "MUBinGraph*" "-I" "LINK/graph/UBinGraph.h" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" "-d" "graph" "-f" "_uBinGraph_" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/UBinGraph.h>

#include <LINK/stkWrapper/Wrapper.h>
#include <LINK/stkWrapper/Register.h>

void display_graphptr(SCM, SCM, int);
void mark_graphptr(SCM);
void free_graphptr(SCM);

typedef UBinGraph* _UBinGraph_;

#define _UBinGraph_DATA(x) ((UBinGraph**) (EXTDATA(x)))
#define _UBinGraph_IS_DATA(x) (TYPEP(x, tc_CXXwrapper) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UBinGraph* >::type))
#define _UBinGraph_ISNT_DATA(x) (!_UBinGraph_IS_DATA(x))

#define _UBinGraph_CXX_DATA(x) (*(UBinGraph**) (EXTDATA(VAL(x))))
#define _UBinGraph_CXX_IS_DATA(x) (INSTANCEP(x) && \
		TYPEP(STk_slot_ref(x,val_scm), tc_CXXwrapper) && \
		(EXTID(STk_slot_ref(x,val_scm)) == Wrapper<UBinGraph* >::type))
#define _UBinGraph_CXX_ISNT_DATA(x) (!_UBinGraph_CXX_IS_DATA(x))



// define your new methods above 
// and register them using STk_add_new_cpp_primitive() below

void genExtra_uBinGraph_Methods() {}