///home/berryj/link/bin/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__;
static Array<Vertex* > s__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) (!_Array_Vertex__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) (!_Array_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__Array_Vertex__()
{
	Wrapper<_Array_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Array_Vertex__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_Vertex_>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_Vertex_>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_Vertex_>::freeTypedArray);
	Tcl_InitHashTable(&Register<_Array_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Array_Vertex__Methods(void);

PRIMITIVE STk_init_methods__Array_Vertex__()
{
	STk_add_new_cpp_primitive("Vector-Vertex-make", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::makeLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-make2", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::makeFilledLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::refLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::linkArrayP);
	STk_add_new_cpp_primitive("vector-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::buildLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-fill!", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::fillLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-copy", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::copyLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-set!", tc_subr_3, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::setLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-length", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::lengthLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::eqvLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::lthLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::leLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex->", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::grLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::geLinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex-vector-resize", tc_subr_2, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::resizeLinkArray);
	STk_add_new_cpp_primitive("list->Vector-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::stkList2LinkArray);
	STk_add_new_cpp_primitive("Vector-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ArrayWrapper<_Vertex_>::linkArray2STkList);

	addOneArgMethod("vector-copy",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-vector-copy", LINK_OVL);
	addOneArgMethod("vector->list",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-vector->list", LINK_OVL);
	addOneArgMethod("vector-length",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-vector-length", LINK_OVL);
	addTwoArgMethod("vector-ref",
		Wrapper<_Array_Vertex__ >::name, 
		"<integer>",
		"Vector-Vertex-vector-ref", LINK_OVL);
	addTwoArgMethod("vector-fill!",
		Wrapper<_Array_Vertex__ >::name, 
		Wrapper<_Vertex_ >::name, 
		"Vector-Vertex-vector-fill!", LINK_OVL);
	addTwoArgMethod("vector-resize",
		Wrapper<_Array_Vertex__ >::name, 
		"<integer>",
		"Vector-Vertex-vector-resize", LINK_OVL);
	addThreeArgMethod("vector-set!",
		Wrapper<_Array_Vertex__ >::name, 
		"<integer>",
		Wrapper<_Vertex_ >::name, 
		"Vector-Vertex-vector-set!", LINK_OVL);
	addTwoArgMethod("eqv?",
		Wrapper<_Array_Vertex__ >::name, 
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Array_Vertex__ >::name, 
		"Vector-Vertex->=", LINK_OVL);
	genExtra_Array_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_AttributeBaseIS_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) (!_AttributeBaseCXX_IS_DATA(x))


PRIMITIVE STk_init__AttributeBase()
{
	Wrapper<_AttributeBase>::type = STk_new_CXXwrapper_id(
			Wrapper<_AttributeBase>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attribute,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_attribute);
	Tcl_InitHashTable(&Register<_AttributeBase>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_AttributeBaseMethods(void);

PRIMITIVE STk_init_methods__AttributeBase()
{
	genExtra_AttributeBaseMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_AttributeBase_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) (!_AttributeBase_CXX_IS_DATA(x))


static SCM is_AttributeBase_(SCM i)
{
	if (_AttributeBase_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__AttributeBase_()
{
	Wrapper<_AttributeBase_>::type = STk_new_CXXwrapper_id(
			Wrapper<_AttributeBase_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attributeptr,
			(void (*)(SCM x))mark_attributeptr,
			(void (*)(SCM x))free_attributeptr);
	Tcl_InitHashTable(&Register<_AttributeBase_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("AttributeBase?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_AttributeBase_);
	return UNDEFINED;
}

void genExtra_AttributeBase_Methods(void);

PRIMITIVE STk_init_methods__AttributeBase_()
{
	genExtra_AttributeBase_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_Attribute_String__(SCM i)
{
	if (_Attribute_String__CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Attribute_String__()
{
	Wrapper<_Attribute_String__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Attribute_String__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attribute_stringptr,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Attribute_String__>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Attribute-String?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Attribute_String__);
	return UNDEFINED;
}

void genExtra_Attribute_String__Methods(void);

PRIMITIVE STk_init_methods__Attribute_String__()
{
	genExtra_Attribute_String__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_Attribute_Vertex___(SCM i)
{
	if (_Attribute_Vertex___CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Attribute_Vertex___()
{
	Wrapper<_Attribute_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Attribute_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attribute_vertexptr,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Attribute_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Attribute-Vertex?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Attribute_Vertex___);
	return UNDEFINED;
}

void genExtra_Attribute_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Attribute_Vertex___()
{
	genExtra_Attribute_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-t" "Attribute<double>*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute_doubleptr" 
#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))


static SCM is_Attribute_double__(SCM i)
{
	if (_Attribute_double__CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Attribute_double__()
{
	Wrapper<_Attribute_double__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Attribute_double__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attribute_doubleptr,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Attribute_double__>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Attribute-double?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Attribute_double__);
	return UNDEFINED;
}

void genExtra_Attribute_double__Methods(void);

PRIMITIVE STk_init_methods__Attribute_double__()
{
	genExtra_Attribute_double__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-t" "Attribute<int>*" "-I" "LINK/graph/Attribute.h" "-d" "graph" "-y" "display_attribute_intptr" 
#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))


static SCM is_Attribute_int__(SCM i)
{
	if (_Attribute_int__CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Attribute_int__()
{
	Wrapper<_Attribute_int__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Attribute_int__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_attribute_intptr,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Attribute_int__>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Attribute-int?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Attribute_int__);
	return UNDEFINED;
}

void genExtra_Attribute_int__Methods(void);

PRIMITIVE STk_init_methods__Attribute_int__()
{
	genExtra_Attribute_int__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_AttributeBase__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) (!_Collection_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_AttributeBase__()
{
	Wrapper<_Collection_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_AttributeBase__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_AttributeBase_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__Collection_AttributeBase__()
{
	STk_add_new_cpp_primitive("collection-AttributeBase?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collectionP);
	STk_add_new_cpp_primitive("mset-AttributeBase1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::buildMSet);
	STk_add_new_cpp_primitive("set-AttributeBase1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::buildSet);
	STk_add_new_cpp_primitive("sequence-AttributeBase1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-AttributeBase-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-AttributeBase-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-AttributeBase", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-AttributeBase", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-AttributeBase", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-AttributeBase->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkList);
	STk_add_new_cpp_primitive("set-AttributeBase->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-AttributeBase->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-AttributeBase->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkString);
	STk_add_new_cpp_primitive("set-AttributeBase->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-AttributeBase->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_AttributeBase_>::collection2STkString);

	addListMethod("mset-AttributeBase",
		"mset-AttributeBase1", LINK_NEW);
	addListMethod("set-AttributeBase",
		"set-AttributeBase1", LINK_NEW);
	addListMethod("sequence-AttributeBase",
		"sequence-AttributeBase1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_AttributeBase__ >::name, 
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_AttributeBase_ >::name, 
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"<integer>",
		"Collection-AttributeBase-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_AttributeBase_ >::name, 
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_AttributeBase_ >::name, 
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_AttributeBase_ >::name, 
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_AttributeBase__ >::name, 
		"Collection-AttributeBase--", LINK_OVL);
	genExtra_Collection_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_Edge__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) (!_Collection_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Edge__()
{
	Wrapper<_Collection_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Edge__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Edge_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Edge__Methods(void);

PRIMITIVE STk_init_methods__Collection_Edge__()
{
	STk_add_new_cpp_primitive("collection-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collectionP);
	STk_add_new_cpp_primitive("mset-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::buildMSet);
	STk_add_new_cpp_primitive("set-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::buildSet);
	STk_add_new_cpp_primitive("sequence-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Edge-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Edge-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkList);
	STk_add_new_cpp_primitive("set-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkString);
	STk_add_new_cpp_primitive("set-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Edge_>::collection2STkString);

	addListMethod("mset-Edge",
		"mset-Edge1", LINK_NEW);
	addListMethod("set-Edge",
		"set-Edge1", LINK_NEW);
	addListMethod("sequence-Edge",
		"sequence-Edge1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Edge__ >::name, 
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Edge_ >::name, 
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Edge__ >::name, 
		"<integer>",
		"Collection-Edge-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Edge_ >::name, 
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Edge_ >::name, 
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Edge_ >::name, 
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Edge__ >::name, 
		"Collection-Edge--", LINK_OVL);
	genExtra_Collection_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_Graph__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) (!_Collection_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Graph__()
{
	Wrapper<_Collection_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Graph__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Graph_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Graph__Methods(void);

PRIMITIVE STk_init_methods__Collection_Graph__()
{
	STk_add_new_cpp_primitive("collection-Graph?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collectionP);
	STk_add_new_cpp_primitive("mset-Graph1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::buildMSet);
	STk_add_new_cpp_primitive("set-Graph1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::buildSet);
	STk_add_new_cpp_primitive("sequence-Graph1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Graph-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Graph-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Graph", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Graph", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Graph", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Graph->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkList);
	STk_add_new_cpp_primitive("set-Graph->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Graph->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Graph->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkString);
	STk_add_new_cpp_primitive("set-Graph->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Graph->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Graph_>::collection2STkString);

	addListMethod("mset-Graph",
		"mset-Graph1", LINK_NEW);
	addListMethod("set-Graph",
		"set-Graph1", LINK_NEW);
	addListMethod("sequence-Graph",
		"sequence-Graph1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Graph__ >::name, 
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Graph_ >::name, 
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Graph__ >::name, 
		"<integer>",
		"Collection-Graph-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Graph_ >::name, 
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Graph_ >::name, 
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Graph_ >::name, 
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Graph__ >::name, 
		"Collection-Graph--", LINK_OVL);
	genExtra_Collection_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "Collection" "-c" "Edge*" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Sequence_Edge__;
typedef Collection<Sequence<Edge*> > _Collection_Sequence_Edge___;

#define _Collection_Sequence_Edge___DATA(x) ((Collection<Sequence<Edge*> >*) (EXTDATA(x)))
#define _Collection_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<Collection<Sequence<Edge*> > >::type))
#define _Collection_Sequence_Edge___ISNT_DATA(x) (!_Collection_Sequence_Edge___IS_DATA(x))

#define _Collection_Sequence_Edge___CXX_DATA(x) (*(Collection<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _Collection_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<Collection<Sequence<Edge*> > >::type))
#define _Collection_Sequence_Edge___CXX_ISNT_DATA(x) (!_Collection_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Sequence_Edge___()
{
	Wrapper<_Collection_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Sequence_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__Collection_Sequence_Edge___()
{
	STk_add_new_cpp_primitive("collection-Sequence-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collectionP);
	STk_add_new_cpp_primitive("mset-Sequence-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::buildMSet);
	STk_add_new_cpp_primitive("set-Sequence-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::buildSet);
	STk_add_new_cpp_primitive("sequence-Sequence-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Sequence-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Sequence-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Sequence-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Sequence-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("set-Sequence-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Sequence-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Sequence-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("set-Sequence-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Sequence-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::choose);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::powerSet);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::permutations);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::permutation);
	STk_add_new_cpp_primitive("Collection-Sequence-Edge-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::rank);

	addListMethod("mset-Sequence-Edge",
		"mset-Sequence-Edge1", LINK_NEW);
	addListMethod("set-Sequence-Edge",
		"set-Sequence-Edge1", LINK_NEW);
	addListMethod("sequence-Sequence-Edge",
		"sequence-Sequence-Edge1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Sequence_Edge__ >::name, 
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"<integer>",
		"Collection-Sequence-Edge-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Sequence_Edge__ >::name, 
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Sequence_Edge__ >::name, 
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Sequence_Edge__ >::name, 
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Sequence_Edge___ >::name, 
		"Collection-Sequence-Edge--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Sequence_Edge__ >::name, 
		Wrapper<_Sequence_Edge__ >::name, 
		"Collection-Sequence-Edge-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Sequence_Edge__ >::name, 
		"<integer>",
		"Collection-Sequence-Edge-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Sequence_Edge__ >::name, 
		"Collection-Sequence-Edge-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Sequence_Edge__ >::name, 
		"Collection-Sequence-Edge-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Sequence_Edge__ >::name, 
		"<integer>",
		"Collection-Sequence-Edge-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Sequence_Edge__ >::name, 
		"Collection-Sequence-Edge-permutation-rank", LINK_NEW);
	genExtra_Collection_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init__Collection_Sequence_Vertex___()
{
	Wrapper<_Collection_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Sequence_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Collection_Sequence_Vertex___()
{
	STk_add_new_cpp_primitive("collection-Sequence-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collectionP);
	STk_add_new_cpp_primitive("mset-Sequence-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::buildMSet);
	STk_add_new_cpp_primitive("set-Sequence-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::buildSet);
	STk_add_new_cpp_primitive("sequence-Sequence-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Sequence-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Sequence-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Sequence-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Sequence-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("set-Sequence-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Sequence-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Sequence-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("set-Sequence-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Sequence-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Sequence_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::choose);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::powerSet);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::permutations);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::permutation);
	STk_add_new_cpp_primitive("Collection-Sequence-Vertex-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::rank);

	addListMethod("mset-Sequence-Vertex",
		"mset-Sequence-Vertex1", LINK_NEW);
	addListMethod("set-Sequence-Vertex",
		"set-Sequence-Vertex1", LINK_NEW);
	addListMethod("sequence-Sequence-Vertex",
		"sequence-Sequence-Vertex1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Sequence_Vertex__ >::name, 
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"<integer>",
		"Collection-Sequence-Vertex-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Sequence_Vertex__ >::name, 
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Sequence_Vertex__ >::name, 
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Sequence_Vertex__ >::name, 
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Sequence_Vertex___ >::name, 
		"Collection-Sequence-Vertex--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Sequence_Vertex__ >::name, 
		Wrapper<_Sequence_Vertex__ >::name, 
		"Collection-Sequence-Vertex-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Sequence_Vertex__ >::name, 
		"<integer>",
		"Collection-Sequence-Vertex-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Sequence_Vertex__ >::name, 
		"Collection-Sequence-Vertex-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Sequence_Vertex__ >::name, 
		"Collection-Sequence-Vertex-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Sequence_Vertex__ >::name, 
		"<integer>",
		"Collection-Sequence-Vertex-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Sequence_Vertex__ >::name, 
		"Collection-Sequence-Vertex-permutation-rank", LINK_NEW);
	genExtra_Collection_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "Collection" "-c" "Edge*" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Set_Edge__;
typedef Collection<Set<Edge*> > _Collection_Set_Edge___;

#define _Collection_Set_Edge___DATA(x) ((Collection<Set<Edge*> >*) (EXTDATA(x)))
#define _Collection_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<Collection<Set<Edge*> > >::type))
#define _Collection_Set_Edge___ISNT_DATA(x) (!_Collection_Set_Edge___IS_DATA(x))

#define _Collection_Set_Edge___CXX_DATA(x) (*(Collection<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _Collection_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<Collection<Set<Edge*> > >::type))
#define _Collection_Set_Edge___CXX_ISNT_DATA(x) (!_Collection_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Set_Edge___()
{
	Wrapper<_Collection_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Set_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__Collection_Set_Edge___()
{
	STk_add_new_cpp_primitive("collection-Set-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collectionP);
	STk_add_new_cpp_primitive("mset-Set-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::buildMSet);
	STk_add_new_cpp_primitive("set-Set-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::buildSet);
	STk_add_new_cpp_primitive("sequence-Set-Edge1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Set-Edge-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Edge-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Set-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Set-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Set-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Set-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("set-Set-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Set-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Set-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("set-Set-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Set-Edge->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Edge__>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Set-Edge-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Set-Edge-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::choose);
	STk_add_new_cpp_primitive("Collection-Set-Edge-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::powerSet);
	STk_add_new_cpp_primitive("Collection-Set-Edge-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::permutations);
	STk_add_new_cpp_primitive("Collection-Set-Edge-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::permutation);
	STk_add_new_cpp_primitive("Collection-Set-Edge-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Edge* >::rank);

	addListMethod("mset-Set-Edge",
		"mset-Set-Edge1", LINK_NEW);
	addListMethod("set-Set-Edge",
		"set-Set-Edge1", LINK_NEW);
	addListMethod("sequence-Set-Edge",
		"sequence-Set-Edge1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Set_Edge___ >::name, 
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Set_Edge__ >::name, 
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"<integer>",
		"Collection-Set-Edge-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Set_Edge__ >::name, 
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Set_Edge__ >::name, 
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Set_Edge__ >::name, 
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Set_Edge___ >::name, 
		"Collection-Set-Edge--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Set_Edge__ >::name, 
		Wrapper<_Set_Edge__ >::name, 
		"Collection-Set-Edge-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Set_Edge__ >::name, 
		"<integer>",
		"Collection-Set-Edge-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Set_Edge__ >::name, 
		"Collection-Set-Edge-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Set_Edge__ >::name, 
		"Collection-Set-Edge-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Set_Edge__ >::name, 
		"<integer>",
		"Collection-Set-Edge-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Set_Edge__ >::name, 
		"Collection-Set-Edge-permutation-rank", LINK_NEW);
	genExtra_Collection_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_Set_Vertex___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) (!_Collection_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Set_Vertex___()
{
	Wrapper<_Collection_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Set_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Collection_Set_Vertex___()
{
	STk_add_new_cpp_primitive("collection-Set-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collectionP);
	STk_add_new_cpp_primitive("mset-Set-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::buildMSet);
	STk_add_new_cpp_primitive("set-Set-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::buildSet);
	STk_add_new_cpp_primitive("sequence-Set-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Set-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Set-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Set-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Set-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("set-Set-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Set-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Set-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("set-Set-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Set-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Set_Vertex__>::collection2STkString);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-cartesian-product", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::cartesianProduct);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-choose", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::choose);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-power-set", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::powerSet);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-permutations", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::permutations);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-permutation", tc_subr_2, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::permutation);
	STk_add_new_cpp_primitive("Collection-Set-Vertex-permutation-rank", tc_subr_1, 
	(PRIMITIVE (*)(...))  SetFuncsWrapper<Vertex* >::rank);

	addListMethod("mset-Set-Vertex",
		"mset-Set-Vertex1", LINK_NEW);
	addListMethod("set-Set-Vertex",
		"set-Set-Vertex1", LINK_NEW);
	addListMethod("sequence-Set-Vertex",
		"sequence-Set-Vertex1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Set_Vertex__ >::name, 
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"<integer>",
		"Collection-Set-Vertex-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Set_Vertex__ >::name, 
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Set_Vertex__ >::name, 
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Set_Vertex__ >::name, 
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Set_Vertex___ >::name, 
		"Collection-Set-Vertex--", LINK_OVL);
	addTwoArgMethod("cartesian-product",
		Wrapper<_Set_Vertex__ >::name, 
		Wrapper<_Set_Vertex__ >::name, 
		"Collection-Set-Vertex-cartesian-product", LINK_NEW);
	addTwoArgMethod("choose",
		Wrapper<_Set_Vertex__ >::name, 
		"<integer>",
		"Collection-Set-Vertex-choose", LINK_NEW);
	addOneArgMethod("power-set",
		Wrapper<_Set_Vertex__ >::name, 
		"Collection-Set-Vertex-power-set", LINK_NEW);
	addOneArgMethod("permutations",
		Wrapper<_Set_Vertex__ >::name, 
		"Collection-Set-Vertex-permutations", LINK_NEW);
	addTwoArgMethod("permutation",
		Wrapper<_Set_Vertex__ >::name, 
		"<integer>",
		"Collection-Set-Vertex-permutation", LINK_NEW);
	addOneArgMethod("permutation-rank",
		Wrapper<_Set_Vertex__ >::name, 
		"Collection-Set-Vertex-permutation-rank", LINK_NEW);
	genExtra_Collection_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_SubSet_Vertex___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) (!_Collection_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_SubSet_Vertex___()
{
	Wrapper<_Collection_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_SubSet_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Collection_SubSet_Vertex___()
{
	genExtra_Collection_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Collection_Vertex__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) (!_Collection_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__Collection_Vertex__()
{
	Wrapper<_Collection_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Collection_Vertex__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Vertex_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Collection_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Collection_Vertex__Methods(void);

PRIMITIVE STk_init_methods__Collection_Vertex__()
{
	STk_add_new_cpp_primitive("collection-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collectionP);
	STk_add_new_cpp_primitive("mset-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::buildMSet);
	STk_add_new_cpp_primitive("set-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::buildSet);
	STk_add_new_cpp_primitive("sequence-Vertex1", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::buildSequence);
	STk_add_new_cpp_primitive("Collection-Vertex-sorted?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::sortedLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-size", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::sizeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-null?", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::nullLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-eqv?", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::eqvLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-<", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::lthLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-<=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::leLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex->", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::grLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex->=", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::geLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-member", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::memberLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-clear!", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::clearLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-insert!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::insertLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-append!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::appendLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-remove!", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::removeLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-occurrences", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::occurrencesLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-ref", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::refLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-rank", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::rankLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-+", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::unionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-^", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::intersectionLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex--", tc_subr_1_or_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::differenceLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::subsetLinkCollection);
	STk_add_new_cpp_primitive("Collection-Vertex-proper-subset", tc_subr_2, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::properSubsetLinkCollection);
	STk_add_new_cpp_primitive("list->mset-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::stkList2LinkMSet);
	STk_add_new_cpp_primitive("list->set-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::stkList2LinkSet);
	STk_add_new_cpp_primitive("list->sequence-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::stkList2LinkSequence);
	STk_add_new_cpp_primitive("mset-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkList);
	STk_add_new_cpp_primitive("set-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkList);
	STk_add_new_cpp_primitive("sequence-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkList);
	STk_add_new_cpp_primitive("mset-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkString);
	STk_add_new_cpp_primitive("set-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkString);
	STk_add_new_cpp_primitive("sequence-Vertex->string", tc_subr_1, 
	(PRIMITIVE (*)(...))  CollectionWrapper<_Vertex_>::collection2STkString);

	addListMethod("mset-Vertex",
		"mset-Vertex1", LINK_NEW);
	addListMethod("set-Vertex",
		"set-Vertex1", LINK_NEW);
	addListMethod("sequence-Vertex",
		"sequence-Vertex1", LINK_NEW);
	addOneArgMethod("null?",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-null?", LINK_OVL);
	addOneArgMethod("size",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-size", LINK_NEW);
	addTwoArgMethod("eqv?",
		Wrapper<_Collection_Vertex__ >::name, 
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-eqv?", LINK_OVL);
	addBooleanMethod("<",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-<", LINK_OVL);
	addBooleanMethod("<=",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-<=", LINK_OVL);
	addBooleanMethod(">",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex->", LINK_OVL);
	addBooleanMethod(">=",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex->=", LINK_OVL);
	addTwoArgMethod("member",
		Wrapper<_Vertex_ >::name, 
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-member", LINK_OVL);
	addTwoArgMethod("ref",
		Wrapper<_Collection_Vertex__ >::name, 
		"<integer>",
		"Collection-Vertex-ref", LINK_NEW);
	addOneArgMethod("clear!",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-clear!", LINK_NEW);
	addTwoArgMethod("insert!",
		Wrapper<_Vertex_ >::name, 
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-insert!", LINK_NEW);
	addTwoArgMethod("append!",
		Wrapper<_Vertex_ >::name, 
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-append!", LINK_NEW);
	addTwoArgMethod("remove!",
		Wrapper<_Vertex_ >::name, 
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-remove!", LINK_NEW);
	addArbMethod("+",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-+", LINK_OVL);
	addArbMethod("^",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex-^", LINK_NEW);
	addArbMethod("-",
		Wrapper<_Collection_Vertex__ >::name, 
		"Collection-Vertex--", LINK_OVL);
	genExtra_Collection_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_AttributeBase__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) (!_Container_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_AttributeBase__()
{
	Wrapper<_Container_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_AttributeBase__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__Container_AttributeBase__()
{
	genExtra_Container_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_Edge__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) (!_Container_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Edge__()
{
	Wrapper<_Container_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Edge__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Edge__Methods(void);

PRIMITIVE STk_init_methods__Container_Edge__()
{
	genExtra_Container_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_Graph__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) (!_Container_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Graph__()
{
	Wrapper<_Container_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Graph__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Graph__Methods(void);

PRIMITIVE STk_init_methods__Container_Graph__()
{
	genExtra_Container_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "Container" "-I" "LINK/graph/Edge.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/Edge.h>

#include <LINK/basic/Sequence.h>

#include <LINK/basic/Container.h>

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


typedef Sequence<Edge*> _Sequence_Edge__;
typedef Container<Sequence<Edge*> > _Container_Sequence_Edge___;

#define _Container_Sequence_Edge___DATA(x) ((Container<Sequence<Edge*> >*) (EXTDATA(x)))
#define _Container_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<Container<Sequence<Edge*> > >::type))
#define _Container_Sequence_Edge___ISNT_DATA(x) (!_Container_Sequence_Edge___IS_DATA(x))

#define _Container_Sequence_Edge___CXX_DATA(x) (*(Container<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _Container_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<Container<Sequence<Edge*> > >::type))
#define _Container_Sequence_Edge___CXX_ISNT_DATA(x) (!_Container_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Sequence_Edge___()
{
	Wrapper<_Container_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Sequence_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__Container_Sequence_Edge___()
{
	genExtra_Container_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init__Container_Sequence_Vertex___()
{
	Wrapper<_Container_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Sequence_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Container_Sequence_Vertex___()
{
	genExtra_Container_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "Container" "-I" "LINK/graph/Edge.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/Edge.h>

#include <LINK/basic/Set.h>

#include <LINK/basic/Container.h>

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


typedef Set<Edge*> _Set_Edge__;
typedef Container<Set<Edge*> > _Container_Set_Edge___;

#define _Container_Set_Edge___DATA(x) ((Container<Set<Edge*> >*) (EXTDATA(x)))
#define _Container_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<Container<Set<Edge*> > >::type))
#define _Container_Set_Edge___ISNT_DATA(x) (!_Container_Set_Edge___IS_DATA(x))

#define _Container_Set_Edge___CXX_DATA(x) (*(Container<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _Container_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<Container<Set<Edge*> > >::type))
#define _Container_Set_Edge___CXX_ISNT_DATA(x) (!_Container_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Set_Edge___()
{
	Wrapper<_Container_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Set_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__Container_Set_Edge___()
{
	genExtra_Container_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_Set_Vertex___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) (!_Container_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Set_Vertex___()
{
	Wrapper<_Container_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Set_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Container_Set_Vertex___()
{
	genExtra_Container_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_SubSet_Vertex___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) (!_Container_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_SubSet_Vertex___()
{
	Wrapper<_Container_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_SubSet_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Container_SubSet_Vertex___()
{
	genExtra_Container_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Container_Vertex__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) (!_Container_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__Container_Vertex__()
{
	Wrapper<_Container_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Container_Vertex__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))0,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_Container_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Container_Vertex__Methods(void);

PRIMITIVE STk_init_methods__Container_Vertex__()
{
	genExtra_Container_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_EdgeIS_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) (!_EdgeCXX_IS_DATA(x))


PRIMITIVE STk_init__Edge()
{
	Wrapper<_Edge>::type = STk_new_CXXwrapper_id(
			Wrapper<_Edge>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_edge,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_edge);
	Tcl_InitHashTable(&Register<_Edge>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_EdgeMethods(void);

PRIMITIVE STk_init_methods__Edge()
{
	genExtra_EdgeMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Edge_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) (!_Edge_CXX_IS_DATA(x))


static SCM is_Edge_(SCM i)
{
	if (_Edge_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Edge_()
{
	Wrapper<_Edge_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Edge_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_edgeptr,
			(void (*)(SCM x))mark_edgeptr,
			(void (*)(SCM x))free_edgeptr);
	Tcl_InitHashTable(&Register<_Edge_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Edge?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Edge_);
	return UNDEFINED;
}

void genExtra_Edge_Methods(void);

PRIMITIVE STk_init_methods__Edge_()
{
	genExtra_Edge_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_GraphIS_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) (!_GraphCXX_IS_DATA(x))


PRIMITIVE STk_init__Graph()
{
	Wrapper<_Graph>::type = STk_new_CXXwrapper_id(
			Wrapper<_Graph>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_Graph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_GraphMethods(void);

PRIMITIVE STk_init_methods__Graph()
{
	genExtra_GraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Graph*" "-I" "LINK/graph/Graph.h" "-d" "graph" "-y" "display_graphptr" "-m" "mark_graphptr" "-w" "free_graphptr" 
#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) (!_Graph_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) (!_Graph_CXX_IS_DATA(x))


static SCM is_Graph_(SCM i)
{
	if (_Graph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Graph_()
{
	Wrapper<_Graph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Graph_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_Graph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Graph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Graph_);
	return UNDEFINED;
}

void genExtra_Graph_Methods(void);

PRIMITIVE STk_init_methods__Graph_()
{
	genExtra_Graph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static List<AttributeBase* > s__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) (!_List_AttributeBase__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) (!_List_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__List_AttributeBase__()
{
	Wrapper<_List_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_AttributeBase__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_AttributeBase_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_AttributeBase_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_AttributeBase_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__List_AttributeBase__()
{
	STk_add_new_cpp_primitive("List-AttributeBase-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_AttributeBase_>::makeLinkList);
	STk_add_new_cpp_primitive("List-AttributeBase?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_AttributeBase_>::linkListP);
	STk_add_new_cpp_primitive("list->List-AttributeBase", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_AttributeBase_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-AttributeBase->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_AttributeBase_>::linkList2STkList);
	genExtra_List_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static List<Edge* > s__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) (!_List_Edge__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) (!_List_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Edge__()
{
	Wrapper<_List_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Edge__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Edge_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Edge_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Edge_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Edge__Methods(void);

PRIMITIVE STk_init_methods__List_Edge__()
{
	STk_add_new_cpp_primitive("List-Edge-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Edge_>::makeLinkList);
	STk_add_new_cpp_primitive("List-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Edge_>::linkListP);
	STk_add_new_cpp_primitive("list->List-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Edge_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Edge_>::linkList2STkList);
	genExtra_List_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static List<Graph* > s__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) (!_List_Graph__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) (!_List_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Graph__()
{
	Wrapper<_List_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Graph__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Graph_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Graph_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Graph_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Graph__Methods(void);

PRIMITIVE STk_init_methods__List_Graph__()
{
	STk_add_new_cpp_primitive("List-Graph-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Graph_>::makeLinkList);
	STk_add_new_cpp_primitive("List-Graph?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Graph_>::linkListP);
	STk_add_new_cpp_primitive("list->List-Graph", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Graph_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Graph->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Graph_>::linkList2STkList);
	genExtra_List_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "List" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Sequence_Edge__;
typedef List<Sequence<Edge*> > _List_Sequence_Edge___;
static List<Sequence<Edge*> > s__List_Sequence_Edge___;

#define _List_Sequence_Edge___DATA(x) ((List<Sequence<Edge*> >*) (EXTDATA(x)))
#define _List_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<List<Sequence<Edge*> > >::type))
#define _List_Sequence_Edge___ISNT_DATA(x) (!_List_Sequence_Edge___IS_DATA(x))

#define _List_Sequence_Edge___CXX_DATA(x) (*(List<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _List_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<List<Sequence<Edge*> > >::type))
#define _List_Sequence_Edge___CXX_ISNT_DATA(x) (!_List_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Sequence_Edge___()
{
	Wrapper<_List_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Sequence_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_Edge__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Edge__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Edge__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__List_Sequence_Edge___()
{
	STk_add_new_cpp_primitive("List-Sequence-Edge-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Edge__>::makeLinkList);
	STk_add_new_cpp_primitive("List-Sequence-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Edge__>::linkListP);
	STk_add_new_cpp_primitive("list->List-Sequence-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Edge__>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Sequence-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Edge__>::linkList2STkList);
	genExtra_List_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static List<Sequence<Vertex*> > s__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))


PRIMITIVE STk_init__List_Sequence_Vertex___()
{
	Wrapper<_List_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Sequence_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__List_Sequence_Vertex___()
{
	STk_add_new_cpp_primitive("List-Sequence-Vertex-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Vertex__>::makeLinkList);
	STk_add_new_cpp_primitive("List-Sequence-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Vertex__>::linkListP);
	STk_add_new_cpp_primitive("list->List-Sequence-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Vertex__>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Sequence-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Sequence_Vertex__>::linkList2STkList);
	genExtra_List_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "List" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Set_Edge__;
typedef List<Set<Edge*> > _List_Set_Edge___;
static List<Set<Edge*> > s__List_Set_Edge___;

#define _List_Set_Edge___DATA(x) ((List<Set<Edge*> >*) (EXTDATA(x)))
#define _List_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<List<Set<Edge*> > >::type))
#define _List_Set_Edge___ISNT_DATA(x) (!_List_Set_Edge___IS_DATA(x))

#define _List_Set_Edge___CXX_DATA(x) (*(List<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _List_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<List<Set<Edge*> > >::type))
#define _List_Set_Edge___CXX_ISNT_DATA(x) (!_List_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Set_Edge___()
{
	Wrapper<_List_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Set_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_Edge__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Edge__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Edge__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__List_Set_Edge___()
{
	STk_add_new_cpp_primitive("List-Set-Edge-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Edge__>::makeLinkList);
	STk_add_new_cpp_primitive("List-Set-Edge?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Edge__>::linkListP);
	STk_add_new_cpp_primitive("list->List-Set-Edge", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Edge__>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Set-Edge->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Edge__>::linkList2STkList);
	genExtra_List_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static List<Set<Vertex*> > s__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) (!_List_Set_Vertex___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) (!_List_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Set_Vertex___()
{
	Wrapper<_List_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Set_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__List_Set_Vertex___()
{
	STk_add_new_cpp_primitive("List-Set-Vertex-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Vertex__>::makeLinkList);
	STk_add_new_cpp_primitive("List-Set-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Vertex__>::linkListP);
	STk_add_new_cpp_primitive("list->List-Set-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Vertex__>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Set-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Set_Vertex__>::linkList2STkList);
	genExtra_List_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static List<SubSet<Vertex*> > s__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) (!_List_SubSet_Vertex___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) (!_List_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__List_SubSet_Vertex___()
{
	Wrapper<_List_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_SubSet_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_SubSet_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__List_SubSet_Vertex___()
{
	genExtra_List_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static List<Vertex* > s__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) (!_List_Vertex__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) (!_List_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__List_Vertex__()
{
	Wrapper<_List_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_List_Vertex__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Vertex_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Vertex_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Vertex_>::freeTypedList);
	Tcl_InitHashTable(&Register<_List_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_List_Vertex__Methods(void);

PRIMITIVE STk_init_methods__List_Vertex__()
{
	STk_add_new_cpp_primitive("List-Vertex-make", tc_subr_0, 
	(PRIMITIVE (*)(...))  ListWrapper<_Vertex_>::makeLinkList);
	STk_add_new_cpp_primitive("List-Vertex?", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Vertex_>::linkListP);
	STk_add_new_cpp_primitive("list->List-Vertex", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Vertex_>::stkList2LinkList);
	STk_add_new_cpp_primitive("List-Vertex->list", tc_subr_1, 
	(PRIMITIVE (*)(...))  ListWrapper<_Vertex_>::linkList2STkList);
	genExtra_List_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static MSet<AttributeBase* > s__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) (!_MSet_AttributeBase__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) (!_MSet_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_AttributeBase__()
{
	Wrapper<_MSet_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_AttributeBase__>::name, 
			Wrapper<Collection<AttributeBase*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_AttributeBase_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__MSet_AttributeBase__()
{
	genExtra_MSet_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static MSet<Edge* > s__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) (!_MSet_Edge__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) (!_MSet_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Edge__()
{
	Wrapper<_MSet_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Edge__>::name, 
			Wrapper<Collection<Edge*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Edge_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Edge__Methods(void);

PRIMITIVE STk_init_methods__MSet_Edge__()
{
	genExtra_MSet_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static MSet<Graph* > s__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) (!_MSet_Graph__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) (!_MSet_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Graph__()
{
	Wrapper<_MSet_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Graph__>::name, 
			Wrapper<Collection<Graph*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Graph_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Graph__Methods(void);

PRIMITIVE STk_init_methods__MSet_Graph__()
{
	genExtra_MSet_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "MSet" "-r" "Collection<Sequence<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Sequence.h>

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


typedef Sequence<Edge*> _Sequence_Edge__;
typedef MSet<Sequence<Edge*> > _MSet_Sequence_Edge___;
static MSet<Sequence<Edge*> > s__MSet_Sequence_Edge___;

#define _MSet_Sequence_Edge___DATA(x) ((MSet<Sequence<Edge*> >*) (EXTDATA(x)))
#define _MSet_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<MSet<Sequence<Edge*> > >::type))
#define _MSet_Sequence_Edge___ISNT_DATA(x) (!_MSet_Sequence_Edge___IS_DATA(x))

#define _MSet_Sequence_Edge___CXX_DATA(x) (*(MSet<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _MSet_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<MSet<Sequence<Edge*> > >::type))
#define _MSet_Sequence_Edge___CXX_ISNT_DATA(x) (!_MSet_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Sequence_Edge___()
{
	Wrapper<_MSet_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Sequence_Edge___>::name, 
			Wrapper<Collection<Sequence<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__MSet_Sequence_Edge___()
{
	genExtra_MSet_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static MSet<Sequence<Vertex*> > s__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))


PRIMITIVE STk_init__MSet_Sequence_Vertex___()
{
	Wrapper<_MSet_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Sequence_Vertex___>::name, 
			Wrapper<Collection<Sequence<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__MSet_Sequence_Vertex___()
{
	genExtra_MSet_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "MSet" "-r" "Collection<Set<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Set.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Set.h>

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


typedef Set<Edge*> _Set_Edge__;
typedef MSet<Set<Edge*> > _MSet_Set_Edge___;
static MSet<Set<Edge*> > s__MSet_Set_Edge___;

#define _MSet_Set_Edge___DATA(x) ((MSet<Set<Edge*> >*) (EXTDATA(x)))
#define _MSet_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<MSet<Set<Edge*> > >::type))
#define _MSet_Set_Edge___ISNT_DATA(x) (!_MSet_Set_Edge___IS_DATA(x))

#define _MSet_Set_Edge___CXX_DATA(x) (*(MSet<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _MSet_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<MSet<Set<Edge*> > >::type))
#define _MSet_Set_Edge___CXX_ISNT_DATA(x) (!_MSet_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Set_Edge___()
{
	Wrapper<_MSet_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Set_Edge___>::name, 
			Wrapper<Collection<Set<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__MSet_Set_Edge___()
{
	genExtra_MSet_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static MSet<Set<Vertex*> > s__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) (!_MSet_Set_Vertex___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) (!_MSet_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Set_Vertex___()
{
	Wrapper<_MSet_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Set_Vertex___>::name, 
			Wrapper<Collection<Set<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__MSet_Set_Vertex___()
{
	genExtra_MSet_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static MSet<SubSet<Vertex*> > s__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) (!_MSet_SubSet_Vertex___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) (!_MSet_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_SubSet_Vertex___()
{
	Wrapper<_MSet_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_SubSet_Vertex___>::name, 
			Wrapper<Collection<SubSet<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__MSet_SubSet_Vertex___()
{
	genExtra_MSet_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static MSet<Vertex* > s__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) (!_MSet_Vertex__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) (!_MSet_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__MSet_Vertex__()
{
	Wrapper<_MSet_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_MSet_Vertex__>::name, 
			Wrapper<Collection<Vertex*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Vertex_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_MSet_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_MSet_Vertex__Methods(void);

PRIMITIVE STk_init_methods__MSet_Vertex__()
{
	genExtra_MSet_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Sequence<AttributeBase* > s__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) (!_Sequence_AttributeBase__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) (!_Sequence_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_AttributeBase__()
{
	Wrapper<_Sequence_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_AttributeBase__>::name, 
			Wrapper<Collection<AttributeBase*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_AttributeBase_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__Sequence_AttributeBase__()
{
	genExtra_Sequence_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Sequence<Edge* > s__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) (!_Sequence_Edge__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) (!_Sequence_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Edge__()
{
	Wrapper<_Sequence_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Edge__>::name, 
			Wrapper<Collection<Edge*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Edge_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Edge__Methods(void);

PRIMITIVE STk_init_methods__Sequence_Edge__()
{
	genExtra_Sequence_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Sequence<Graph* > s__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) (!_Sequence_Graph__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) (!_Sequence_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Graph__()
{
	Wrapper<_Sequence_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Graph__>::name, 
			Wrapper<Collection<Graph*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Graph_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Graph__Methods(void);

PRIMITIVE STk_init_methods__Sequence_Graph__()
{
	genExtra_Sequence_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "Sequence" "-r" "Collection<Sequence<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Sequence.h>

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


typedef Sequence<Edge*> _Sequence_Edge__;
typedef Sequence<Sequence<Edge*> > _Sequence_Sequence_Edge___;
static Sequence<Sequence<Edge*> > s__Sequence_Sequence_Edge___;

#define _Sequence_Sequence_Edge___DATA(x) ((Sequence<Sequence<Edge*> >*) (EXTDATA(x)))
#define _Sequence_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<Sequence<Edge*> > >::type))
#define _Sequence_Sequence_Edge___ISNT_DATA(x) (!_Sequence_Sequence_Edge___IS_DATA(x))

#define _Sequence_Sequence_Edge___CXX_DATA(x) (*(Sequence<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _Sequence_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<Sequence<Edge*> > >::type))
#define _Sequence_Sequence_Edge___CXX_ISNT_DATA(x) (!_Sequence_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Sequence_Edge___()
{
	Wrapper<_Sequence_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Sequence_Edge___>::name, 
			Wrapper<Collection<Sequence<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__Sequence_Sequence_Edge___()
{
	genExtra_Sequence_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Sequence<Sequence<Vertex*> > s__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))


PRIMITIVE STk_init__Sequence_Sequence_Vertex___()
{
	Wrapper<_Sequence_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Sequence_Vertex___>::name, 
			Wrapper<Collection<Sequence<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Sequence_Sequence_Vertex___()
{
	genExtra_Sequence_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "Sequence" "-r" "Collection<Set<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Sequence.h>

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


typedef Set<Edge*> _Set_Edge__;
typedef Sequence<Set<Edge*> > _Sequence_Set_Edge___;
static Sequence<Set<Edge*> > s__Sequence_Set_Edge___;

#define _Sequence_Set_Edge___DATA(x) ((Sequence<Set<Edge*> >*) (EXTDATA(x)))
#define _Sequence_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<Sequence<Set<Edge*> > >::type))
#define _Sequence_Set_Edge___ISNT_DATA(x) (!_Sequence_Set_Edge___IS_DATA(x))

#define _Sequence_Set_Edge___CXX_DATA(x) (*(Sequence<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _Sequence_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<Sequence<Set<Edge*> > >::type))
#define _Sequence_Set_Edge___CXX_ISNT_DATA(x) (!_Sequence_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Set_Edge___()
{
	Wrapper<_Sequence_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Set_Edge___>::name, 
			Wrapper<Collection<Set<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__Sequence_Set_Edge___()
{
	genExtra_Sequence_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Sequence<Set<Vertex*> > s__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) (!_Sequence_Set_Vertex___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) (!_Sequence_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Set_Vertex___()
{
	Wrapper<_Sequence_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Set_Vertex___>::name, 
			Wrapper<Collection<Set<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Sequence_Set_Vertex___()
{
	genExtra_Sequence_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Sequence<SubSet<Vertex*> > s__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) (!_Sequence_SubSet_Vertex___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) (!_Sequence_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_SubSet_Vertex___()
{
	Wrapper<_Sequence_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_SubSet_Vertex___>::name, 
			Wrapper<Collection<SubSet<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Sequence_SubSet_Vertex___()
{
	genExtra_Sequence_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Sequence<Vertex* > s__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) (!_Sequence_Vertex__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) (!_Sequence_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__Sequence_Vertex__()
{
	Wrapper<_Sequence_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Sequence_Vertex__>::name, 
			Wrapper<Collection<Vertex*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Vertex_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Sequence_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Sequence_Vertex__Methods(void);

PRIMITIVE STk_init_methods__Sequence_Vertex__()
{
	genExtra_Sequence_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Set<AttributeBase* > s__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) (!_Set_AttributeBase__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) (!_Set_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_AttributeBase__()
{
	Wrapper<_Set_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_AttributeBase__>::name, 
			Wrapper<MSet<AttributeBase*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_AttributeBase_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_AttributeBase_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__Set_AttributeBase__()
{
	genExtra_Set_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Set<Edge* > s__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) (!_Set_Edge__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) (!_Set_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Edge__()
{
	Wrapper<_Set_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Edge__>::name, 
			Wrapper<MSet<Edge*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Edge_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Edge_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Edge__Methods(void);

PRIMITIVE STk_init_methods__Set_Edge__()
{
	genExtra_Set_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Set<Graph* > s__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) (!_Set_Graph__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) (!_Set_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Graph__()
{
	Wrapper<_Set_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Graph__>::name, 
			Wrapper<MSet<Graph*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Graph_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Graph_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Graph__Methods(void);

PRIMITIVE STk_init_methods__Set_Graph__()
{
	genExtra_Set_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "Set" "-r" "MSet<Sequence<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Sequence.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Sequence.h>

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


typedef Sequence<Edge*> _Sequence_Edge__;
typedef Set<Sequence<Edge*> > _Set_Sequence_Edge___;
static Set<Sequence<Edge*> > s__Set_Sequence_Edge___;

#define _Set_Sequence_Edge___DATA(x) ((Set<Sequence<Edge*> >*) (EXTDATA(x)))
#define _Set_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<Set<Sequence<Edge*> > >::type))
#define _Set_Sequence_Edge___ISNT_DATA(x) (!_Set_Sequence_Edge___IS_DATA(x))

#define _Set_Sequence_Edge___CXX_DATA(x) (*(Set<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _Set_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<Set<Sequence<Edge*> > >::type))
#define _Set_Sequence_Edge___CXX_ISNT_DATA(x) (!_Set_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Sequence_Edge___()
{
	Wrapper<_Set_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Sequence_Edge___>::name, 
			Wrapper<MSet<Sequence<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__Set_Sequence_Edge___()
{
	genExtra_Set_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Set<Sequence<Vertex*> > s__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))


PRIMITIVE STk_init__Set_Sequence_Vertex___()
{
	Wrapper<_Set_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Sequence_Vertex___>::name, 
			Wrapper<MSet<Sequence<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Sequence_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Sequence_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Set_Sequence_Vertex___()
{
	genExtra_Set_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "Set" "-r" "MSet<Set<Edge*> >" "-I" "LINK/graph/Edge.h" "-I" "LINK/basic/Set.h" "-d" "graph" 
#include <stk.h>
#include <LINK/stkWrapper/LINK_STk.h>

#include <LINK/graph/Edge.h>

#include <LINK/basic/Set.h>

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


typedef Set<Edge*> _Set_Edge__;
typedef Set<Set<Edge*> > _Set_Set_Edge___;
static Set<Set<Edge*> > s__Set_Set_Edge___;

#define _Set_Set_Edge___DATA(x) ((Set<Set<Edge*> >*) (EXTDATA(x)))
#define _Set_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<Set<Edge*> > >::type))
#define _Set_Set_Edge___ISNT_DATA(x) (!_Set_Set_Edge___IS_DATA(x))

#define _Set_Set_Edge___CXX_DATA(x) (*(Set<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _Set_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<Set<Edge*> > >::type))
#define _Set_Set_Edge___CXX_ISNT_DATA(x) (!_Set_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Set_Edge___()
{
	Wrapper<_Set_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Set_Edge___>::name, 
			Wrapper<MSet<Set<Edge*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Edge__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Edge__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__Set_Set_Edge___()
{
	genExtra_Set_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Set<Set<Vertex*> > s__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) (!_Set_Set_Vertex___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) (!_Set_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Set_Vertex___()
{
	Wrapper<_Set_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Set_Vertex___>::name, 
			Wrapper<MSet<Set<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Set_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Set_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Set_Set_Vertex___()
{
	genExtra_Set_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static Set<SubSet<Vertex*> > s__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) (!_Set_SubSet_Vertex___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) (!_Set_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_SubSet_Vertex___()
{
	Wrapper<_Set_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_SubSet_Vertex___>::name, 
			Wrapper<MSet<SubSet<Vertex*> > >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_SubSet_Vertex__>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_SubSet_Vertex__>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__Set_SubSet_Vertex___()
{
	genExtra_Set_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static Set<Vertex* > s__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) (!_Set_Vertex__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) (!_Set_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__Set_Vertex__()
{
	Wrapper<_Set_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_Set_Vertex__>::name, 
			Wrapper<MSet<Vertex*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			CollectionWrapper<_Vertex_>::displayTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::markTypedCollection,
			(void (*)(SCM x))CollectionWrapper<_Vertex_>::freeTypedCollection);
	Tcl_InitHashTable(&Register<_Set_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_Set_Vertex__Methods(void);

PRIMITIVE STk_init_methods__Set_Vertex__()
{
	genExtra_Set_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SortedArray<Vertex* > s__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) (!_SortedArray_Vertex__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) (!_SortedArray_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedArray_Vertex__()
{
	Wrapper<_SortedArray_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedArray_Vertex__>::name, 
			Wrapper<Array<Vertex*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ArrayWrapper<_Vertex_>::displayTypedArray,
			(void (*)(SCM x))ArrayWrapper<_Vertex_>::markTypedArray,
			(void (*)(SCM x))ArrayWrapper<_Vertex_>::freeTypedArray);
	Tcl_InitHashTable(&Register<_SortedArray_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedArray_Vertex__Methods(void);

PRIMITIVE STk_init_methods__SortedArray_Vertex__()
{
	genExtra_SortedArray_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SortedList<AttributeBase* > s__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) (!_SortedList_AttributeBase__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) (!_SortedList_AttributeBase__CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_AttributeBase__()
{
	Wrapper<_SortedList_AttributeBase__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_AttributeBase__>::name, 
			Wrapper<List<AttributeBase*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_AttributeBase_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_AttributeBase_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_AttributeBase_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_AttributeBase__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_AttributeBase__Methods(void);

PRIMITIVE STk_init_methods__SortedList_AttributeBase__()
{
	genExtra_SortedList_AttributeBase__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SortedList<Edge* > s__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) (!_SortedList_Edge__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) (!_SortedList_Edge__CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Edge__()
{
	Wrapper<_SortedList_Edge__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Edge__>::name, 
			Wrapper<List<Edge*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Edge_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Edge_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Edge_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Edge__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Edge__Methods(void);

PRIMITIVE STk_init_methods__SortedList_Edge__()
{
	genExtra_SortedList_Edge__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SortedList<Graph* > s__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) (!_SortedList_Graph__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) (!_SortedList_Graph__CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Graph__()
{
	Wrapper<_SortedList_Graph__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Graph__>::name, 
			Wrapper<List<Graph*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Graph_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Graph_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Graph_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Graph__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Graph__Methods(void);

PRIMITIVE STk_init_methods__SortedList_Graph__()
{
	genExtra_SortedList_Graph__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Sequence<Edge*>" "-h" "SortedList" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Sequence_Edge__;
typedef SortedList<Sequence<Edge*> > _SortedList_Sequence_Edge___;
static SortedList<Sequence<Edge*> > s__SortedList_Sequence_Edge___;

#define _SortedList_Sequence_Edge___DATA(x) ((SortedList<Sequence<Edge*> >*) (EXTDATA(x)))
#define _SortedList_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<SortedList<Sequence<Edge*> > >::type))
#define _SortedList_Sequence_Edge___ISNT_DATA(x) (!_SortedList_Sequence_Edge___IS_DATA(x))

#define _SortedList_Sequence_Edge___CXX_DATA(x) (*(SortedList<Sequence<Edge*> >*) (EXTDATA(VAL(x))))
#define _SortedList_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<SortedList<Sequence<Edge*> > >::type))
#define _SortedList_Sequence_Edge___CXX_ISNT_DATA(x) (!_SortedList_Sequence_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Sequence_Edge___()
{
	Wrapper<_SortedList_Sequence_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Sequence_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_Edge__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Edge__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Edge__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Sequence_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Sequence_Edge___Methods(void);

PRIMITIVE STk_init_methods__SortedList_Sequence_Edge___()
{
	genExtra_SortedList_Sequence_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static SortedList<Sequence<Vertex*> > s__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))


PRIMITIVE STk_init__SortedList_Sequence_Vertex___()
{
	Wrapper<_SortedList_Sequence_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Sequence_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Sequence_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Sequence_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Sequence_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Sequence_Vertex___Methods(void);

PRIMITIVE STk_init_methods__SortedList_Sequence_Vertex___()
{
	genExtra_SortedList_Sequence_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/genMethods "-g" "-t" "Set<Edge*>" "-h" "SortedList" "-I" "LINK/graph/Edge.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/Edge.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<Edge*> _Set_Edge__;
typedef SortedList<Set<Edge*> > _SortedList_Set_Edge___;
static SortedList<Set<Edge*> > s__SortedList_Set_Edge___;

#define _SortedList_Set_Edge___DATA(x) ((SortedList<Set<Edge*> >*) (EXTDATA(x)))
#define _SortedList_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<SortedList<Set<Edge*> > >::type))
#define _SortedList_Set_Edge___ISNT_DATA(x) (!_SortedList_Set_Edge___IS_DATA(x))

#define _SortedList_Set_Edge___CXX_DATA(x) (*(SortedList<Set<Edge*> >*) (EXTDATA(VAL(x))))
#define _SortedList_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<SortedList<Set<Edge*> > >::type))
#define _SortedList_Set_Edge___CXX_ISNT_DATA(x) (!_SortedList_Set_Edge___CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Set_Edge___()
{
	Wrapper<_SortedList_Set_Edge___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Set_Edge___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_Edge__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Edge__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Edge__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Set_Edge___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Set_Edge___Methods(void);

PRIMITIVE STk_init_methods__SortedList_Set_Edge___()
{
	genExtra_SortedList_Set_Edge___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static SortedList<Set<Vertex*> > s__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) (!_SortedList_Set_Vertex___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) (!_SortedList_Set_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Set_Vertex___()
{
	Wrapper<_SortedList_Set_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Set_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Set_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Set_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Set_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Set_Vertex___Methods(void);

PRIMITIVE STk_init_methods__SortedList_Set_Vertex___()
{
	genExtra_SortedList_Set_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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___;
static SortedList<SubSet<Vertex*> > s__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) (!_SortedList_SubSet_Vertex___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) (!_SortedList_SubSet_Vertex___CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_SubSet_Vertex___()
{
	Wrapper<_SortedList_SubSet_Vertex___>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_SubSet_Vertex___>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_SubSet_Vertex__>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_Vertex__>::markTypedList,
			(void (*)(SCM x))ListWrapper<_SubSet_Vertex__>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_SubSet_Vertex___>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_SubSet_Vertex___Methods(void);

PRIMITIVE STk_init_methods__SortedList_SubSet_Vertex___()
{
	genExtra_SortedList_SubSet_Vertex___Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SortedList<Vertex* > s__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) (!_SortedList_Vertex__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) (!_SortedList_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__SortedList_Vertex__()
{
	Wrapper<_SortedList_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SortedList_Vertex__>::name, 
			Wrapper<List<Vertex*> >::name,
			(void (*)(SCM x, SCM port, int mode))
			ListWrapper<_Vertex_>::displayTypedList,
			(void (*)(SCM x))ListWrapper<_Vertex_>::markTypedList,
			(void (*)(SCM x))ListWrapper<_Vertex_>::freeTypedList);
	Tcl_InitHashTable(&Register<_SortedList_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SortedList_Vertex__Methods(void);

PRIMITIVE STk_init_methods__SortedList_Vertex__()
{
	genExtra_SortedList_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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__;
static SubSet<Vertex* > s__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) (!_SubSet_Vertex__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) (!_SubSet_Vertex__CXX_IS_DATA(x))


PRIMITIVE STk_init__SubSet_Vertex__()
{
	Wrapper<_SubSet_Vertex__>::type = STk_new_CXXwrapper_id(
			Wrapper<_SubSet_Vertex__>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_subset_vertex,
			(void (*)(SCM x))0,
			(void (*)(SCM x))0);
	Tcl_InitHashTable(&Register<_SubSet_Vertex__>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_SubSet_Vertex__Methods(void);

PRIMITIVE STk_init_methods__SubSet_Vertex__()
{
	genExtra_SubSet_Vertex__Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_VertexIS_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) (!_VertexCXX_IS_DATA(x))


PRIMITIVE STk_init__Vertex()
{
	Wrapper<_Vertex>::type = STk_new_CXXwrapper_id(
			Wrapper<_Vertex>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_vertex,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_vertex);
	Tcl_InitHashTable(&Register<_Vertex>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_VertexMethods(void);

PRIMITIVE STk_init_methods__Vertex()
{
	genExtra_VertexMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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) (!_Vertex_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) (!_Vertex_CXX_IS_DATA(x))


static SCM is_Vertex_(SCM i)
{
	if (_Vertex_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__Vertex_()
{
	Wrapper<_Vertex_>::type = STk_new_CXXwrapper_id(
			Wrapper<_Vertex_>::name, 
			"",
			(void (*)(SCM x, SCM port, int mode))
			display_vertexptr,
			(void (*)(SCM x))mark_vertexptr,
			(void (*)(SCM x))free_vertexptr);
	Tcl_InitHashTable(&Register<_Vertex_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("Vertex?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_Vertex_);
	return UNDEFINED;
}

void genExtra_Vertex_Methods(void);

PRIMITIVE STk_init_methods__Vertex_()
{
	genExtra_Vertex_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init_____mHyperGraph()
{
	Wrapper<_MHyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MHyperGraph>::name, 
			Wrapper<Graph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MHyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra____mHyperGraphMethods(void);

PRIMITIVE STk_init_methods_____mHyperGraph()
{
	genExtra____mHyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MHyperGraph_(SCM i)
{
	if (_MHyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init_____mHyperGraph_()
{
	Wrapper<_MHyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MHyperGraph_>::name, 
			Wrapper<Graph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MHyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MHyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MHyperGraph_);
	return UNDEFINED;
}

void genExtra____mHyperGraph_Methods(void);

PRIMITIVE STk_init_methods_____mHyperGraph_()
{
	genExtra____mHyperGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init____hyperGraph()
{
	Wrapper<_HyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_HyperGraph>::name, 
			Wrapper<MHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_HyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra___hyperGraphMethods(void);

PRIMITIVE STk_init_methods____hyperGraph()
{
	genExtra___hyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_HyperGraph_(SCM i)
{
	if (_HyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init____hyperGraph_()
{
	Wrapper<_HyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_HyperGraph_>::name, 
			Wrapper<MHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_HyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("HyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_HyperGraph_);
	return UNDEFINED;
}

void genExtra___hyperGraph_Methods(void);

PRIMITIVE STk_init_methods____hyperGraph_()
{
	genExtra___hyperGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init____mBinGraph()
{
	Wrapper<_MBinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MBinGraph>::name, 
			Wrapper<MHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MBinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra___mBinGraphMethods(void);

PRIMITIVE STk_init_methods____mBinGraph()
{
	genExtra___mBinGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MBinGraph_(SCM i)
{
	if (_MBinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init____mBinGraph_()
{
	Wrapper<_MBinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MBinGraph_>::name, 
			Wrapper<MHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MBinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MBinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MBinGraph_);
	return UNDEFINED;
}

void genExtra___mBinGraph_Methods(void);

PRIMITIVE STk_init_methods____mBinGraph_()
{
	genExtra___mBinGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init____mDHyperGraph()
{
	Wrapper<_MDHyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MDHyperGraph>::name, 
			Wrapper<MHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MDHyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra___mDHyperGraphMethods(void);

PRIMITIVE STk_init_methods____mDHyperGraph()
{
	genExtra___mDHyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MDHyperGraph_(SCM i)
{
	if (_MDHyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init____mDHyperGraph_()
{
	Wrapper<_MDHyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MDHyperGraph_>::name, 
			Wrapper<MHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MDHyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MDHyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MDHyperGraph_);
	return UNDEFINED;
}

void genExtra___mDHyperGraph_Methods(void);

PRIMITIVE STk_init_methods____mDHyperGraph_()
{
	genExtra___mDHyperGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init____mUHyperGraph()
{
	Wrapper<_MUHyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MUHyperGraph>::name, 
			Wrapper<MHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MUHyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra___mUHyperGraphMethods(void);

PRIMITIVE STk_init_methods____mUHyperGraph()
{
	genExtra___mUHyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MUHyperGraph_(SCM i)
{
	if (_MUHyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init____mUHyper_Graph()
{
	Wrapper<_MUHyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MUHyperGraph_>::name, 
			Wrapper<MHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MUHyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MUHyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MUHyperGraph_);
	return UNDEFINED;
}

void genExtra___mUHyper_GraphMethods(void);

PRIMITIVE STk_init_methods____mUHyper_Graph()
{
	genExtra___mUHyper_GraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init___binGraph()
{
	Wrapper<_BinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_BinGraph>::name, 
			Wrapper<MBinGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_BinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra__binGraphMethods(void);

PRIMITIVE STk_init_methods___binGraph()
{
	genExtra__binGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_BinGraph_(SCM i)
{
	if (_BinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init___binGraph_()
{
	Wrapper<_BinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_BinGraph_>::name, 
			Wrapper<MBinGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_BinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("BinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_BinGraph_);
	return UNDEFINED;
}

void genExtra__binGraph_Methods(void);

PRIMITIVE STk_init_methods___binGraph_()
{
	genExtra__binGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init___dHyperGraph()
{
	Wrapper<_DHyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_DHyperGraph>::name, 
			Wrapper<MDHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_DHyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra__dHyperGraphMethods(void);

PRIMITIVE STk_init_methods___dHyperGraph()
{
	genExtra__dHyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_DHyperGraph_(SCM i)
{
	if (_DHyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init___dHyperGraph_()
{
	Wrapper<_DHyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_DHyperGraph_>::name, 
			Wrapper<MDHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_DHyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("DHyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_DHyperGraph_);
	return UNDEFINED;
}

void genExtra__dHyperGraph_Methods(void);

PRIMITIVE STk_init_methods___dHyperGraph_()
{
	genExtra__dHyperGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init___mDBinGraph()
{
	Wrapper<_MDBinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MDBinGraph>::name, 
			Wrapper<MBinGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MDBinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra__mDBinGraphMethods(void);

PRIMITIVE STk_init_methods___mDBinGraph()
{
	genExtra__mDBinGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MDBinGraph_(SCM i)
{
	if (_MDBinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init___mDBinGraph_()
{
	Wrapper<_MDBinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MDBinGraph_>::name, 
			Wrapper<MBinGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MDBinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MDBinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MDBinGraph_);
	return UNDEFINED;
}

void genExtra__mDBinGraph_Methods(void);

PRIMITIVE STk_init_methods___mDBinGraph_()
{
	genExtra__mDBinGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init___mUBinGraph()
{
	Wrapper<_MUBinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_MUBinGraph>::name, 
			Wrapper<MBinGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_MUBinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra__mUBinGraphMethods(void);

PRIMITIVE STk_init_methods___mUBinGraph()
{
	genExtra__mUBinGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_MUBinGraph_(SCM i)
{
	if (_MUBinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init___mUBinGraph_()
{
	Wrapper<_MUBinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_MUBinGraph_>::name, 
			Wrapper<MBinGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_MUBinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("MUBinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_MUBinGraph_);
	return UNDEFINED;
}

void genExtra__mUBinGraph_Methods(void);

PRIMITIVE STk_init_methods___mUBinGraph_()
{
	genExtra__mUBinGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init___uHyperGraph()
{
	Wrapper<_UHyperGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_UHyperGraph>::name, 
			Wrapper<MUHyperGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_UHyperGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra__uHyperGraphMethods(void);

PRIMITIVE STk_init_methods___uHyperGraph()
{
	genExtra__uHyperGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_UHyperGraph_(SCM i)
{
	if (_UHyperGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init___uHyperGraph_()
{
	Wrapper<_UHyperGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_UHyperGraph_>::name, 
			Wrapper<MUHyperGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_UHyperGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("UHyperGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_UHyperGraph_);
	return UNDEFINED;
}

void genExtra__uHyperGraph_Methods(void);

PRIMITIVE STk_init_methods___uHyperGraph_()
{
	genExtra__uHyperGraph_Methods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


PRIMITIVE STk_init__dBinGraph()
{
	Wrapper<_DBinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_DBinGraph>::name, 
			Wrapper<MDBinGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_DBinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_dBinGraphMethods(void);

PRIMITIVE STk_init_methods__dBinGraph()
{
	genExtra_dBinGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_DBinGraph_(SCM i)
{
	if (_DBinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__dBinGraph_()
{
	Wrapper<_DBinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_DBinGraph_>::name, 
			Wrapper<MDBinGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_DBinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("DBinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_DBinGraph_);
	return UNDEFINED;
}

void genExtra_dBinGraph_Methods(void);

PRIMITIVE STk_init_methods__dBinGraph_()
{
	genExtra_dBinGraph_Methods();
	return UNDEFINED;
}
// this file merely satisfies sccs in Make.*
///home/berryj/link/bin/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))


PRIMITIVE STk_init__uBinGraph()
{
	Wrapper<_UBinGraph>::type = STk_new_CXXwrapper_id(
			Wrapper<_UBinGraph>::name, 
			Wrapper<MUBinGraph >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graph,
			(void (*)(SCM x))0,
			(void (*)(SCM x))free_graph);
	Tcl_InitHashTable(&Register<_UBinGraph>::objTable, TCL_ONE_WORD_KEYS);
	return UNDEFINED;
}

void genExtra_uBinGraphMethods(void);

PRIMITIVE STk_init_methods__uBinGraph()
{
	genExtra_uBinGraphMethods();
	return UNDEFINED;
}
///home/berryj/link/bin/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))


static SCM is_UBinGraph_(SCM i)
{
	if (_UBinGraph_CXX_IS_DATA(i))
		return Truth;
	return Ntruth;
}

PRIMITIVE STk_init__uBinGraph_()
{
	Wrapper<_UBinGraph_>::type = STk_new_CXXwrapper_id(
			Wrapper<_UBinGraph_>::name, 
			Wrapper<MUBinGraph* >::name,
			(void (*)(SCM x, SCM port, int mode))
			display_graphptr,
			(void (*)(SCM x))mark_graphptr,
			(void (*)(SCM x))free_graphptr);
	Tcl_InitHashTable(&Register<_UBinGraph_>::objTable, TCL_ONE_WORD_KEYS);
	STk_add_new_cpp_primitive("UBinGraph?", tc_subr_1,
	(PRIMITIVE (*)(...))  is_UBinGraph_);
	return UNDEFINED;
}

void genExtra_uBinGraph_Methods(void);

PRIMITIVE STk_init_methods__uBinGraph_()
{
	genExtra_uBinGraph_Methods();
	return UNDEFINED;
}
