only moving to a new directory

svn path=/trunk/externals/grh/; revision=3740

21 files changed, 3540 insertions, 0 deletions

diff --git a/PDContainer/src/HDeque.cpp b/PDContainer/src/HDeque.cpp
new file mode 100755
index 0000000..3a1c317
--- /dev/null
+++ b/PDContainer/src/HDeque.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HDeque.cpp
+
+
+#include "include/HDeque.h"
+
diff --git a/PDContainer/src/HList.cpp b/PDContainer/src/HList.cpp
new file mode 100755
index 0000000..9a5935f
--- /dev/null
+++ b/PDContainer/src/HList.cpp
@@ -0,0 +1,111 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HList.cpp
+
+
+#include "include/HList.h"
+
+
+//----------------------------------------------------
+/* reads from an input file and adds the data to
+ * the current namespace
+ * Fileformat: see saveToFile
+ * returns true on success
+ */
+bool HList::readFromFile(string filename)
+{
+  makeIterator();
+
+  ifstream infile;
+  infile.open(filename.c_str());
+
+  if(!infile)
+      return false;
+
+  Element key;
+
+  string line;
+  bool go_on = false;
+  char type;
+  string symbol;
+  t_float number;
+  int key_count;
+
+  while (getline(infile, line))
+    {
+      // first parse the instream, to get the number of atoms
+      // (= size of the list)
+
+      istringstream instream(line);
+      ostringstream key_str("");
+      
+      go_on = false; key_count = 0;
+      while(!go_on)
+	{
+	  instream >> type;
+	  if (instream.eof())
+	    {
+	      go_on = true;
+	      break;
+	    }
+	  if (type == 's')
+	    {
+	      key_count++;
+	      instream >> symbol;
+	      key_str << "s " << symbol;
+	    }
+	  if (type == 'f')
+	    {
+	      key_count++;
+	      instream >> number;
+	      key_str << "f " << number;
+	    }
+	  if (instream.eof())
+	    go_on = true;
+	  key_str << " ";
+	}
+
+      // now objects, parse again the data
+      // into the objects and add them to the container
+
+      t_atom *key_atom = (t_atom*)getbytes(key_count*sizeof(t_atom));
+      if(key_atom == NULL)
+	post("Fatal Error Out Of Memory (%s-readFromFile)",dataname_.c_str());
+
+      istringstream key_istr(key_str.str());
+ 
+      for(int i = 0; i < key_count; i++)
+	{
+	  key_istr >> type;
+	  if (type == 's')
+	    {
+	      key_istr >> symbol;
+	      SETSYMBOL(&key_atom[i],gensym(const_cast<char*>(symbol.c_str())));
+	    }
+	  if (type == 'f')
+	    {
+	      key_istr >> number;
+	      SETFLOAT(&key_atom[i],number);
+	    }
+	}
+
+	key.setAtoms(key_count,key_atom);
+
+      // insert the data
+      data_[h_namespace_].insert(iter_,key);
+      
+      freebytes(key_atom, key_count*sizeof(t_atom));
+    }
+
+  infile.close();
+
+  return true;
+}
diff --git a/PDContainer/src/HMap.cpp b/PDContainer/src/HMap.cpp
new file mode 100755
index 0000000..c7e8534
--- /dev/null
+++ b/PDContainer/src/HMap.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HMap.cpp
+
+
+#include "include/HMap.h"
+
diff --git a/PDContainer/src/HMultiMap.cpp b/PDContainer/src/HMultiMap.cpp
new file mode 100755
index 0000000..ecc482e
--- /dev/null
+++ b/PDContainer/src/HMultiMap.cpp
@@ -0,0 +1,38 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HMultiMap.cpp
+
+
+#include "include/HMultiMap.h"
+
+
+//---------------------------------------------------
+/* Get a value from the specific Key with the index number
+ * index starts with 0
+ * returns an element wich points to 0 if nothing was found !!!
+ */
+Element &HMultiMap::get(Element &key, int index) const
+{
+  int count = 0;
+
+  for (multimap<Element,Element>::iterator it = data_[h_namespace_].begin();
+       it != data_[h_namespace_].end(); ++it)
+    {
+      if ((*it).first == key)
+	{
+	  if(index == count++)
+	    return ((*it).second);
+	}
+    }
+
+  // throw an exception if nothing was found
+  throw "h_multimap, get: Element not found !";
+}
diff --git a/PDContainer/src/HMultiSet.cpp b/PDContainer/src/HMultiSet.cpp
new file mode 100755
index 0000000..07dd564
--- /dev/null
+++ b/PDContainer/src/HMultiSet.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HMultiSet.cpp
+
+
+#include "include/HMultiSet.h"
+
diff --git a/PDContainer/src/HPrioQueue.cpp b/PDContainer/src/HPrioQueue.cpp
new file mode 100755
index 0000000..f998530
--- /dev/null
+++ b/PDContainer/src/HPrioQueue.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HPrioQueue.cpp
+
+
+#include "include/HPrioQueue.h"
+
diff --git a/PDContainer/src/HQueue.cpp b/PDContainer/src/HQueue.cpp
new file mode 100755
index 0000000..0fa012b
--- /dev/null
+++ b/PDContainer/src/HQueue.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HQueue.cpp
+
+
+#include "include/HQueue.h"
+
diff --git a/PDContainer/src/HSet.cpp b/PDContainer/src/HSet.cpp
new file mode 100755
index 0000000..f6caf2b
--- /dev/null
+++ b/PDContainer/src/HSet.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HSet.cpp
+
+
+#include "include/HSet.h"
+
diff --git a/PDContainer/src/HStack.cpp b/PDContainer/src/HStack.cpp
new file mode 100755
index 0000000..ea9fc35
--- /dev/null
+++ b/PDContainer/src/HStack.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HStack.cpp
+
+
+#include "include/HStack.h"
+
diff --git a/PDContainer/src/HVector.cpp b/PDContainer/src/HVector.cpp
new file mode 100755
index 0000000..94616c4
--- /dev/null
+++ b/PDContainer/src/HVector.cpp
@@ -0,0 +1,15 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// HVector.cpp
+
+
+#include "include/HVector.h"
+
diff --git a/PDContainer/src/PDContainer.cpp b/PDContainer/src/PDContainer.cpp
new file mode 100755
index 0000000..fc27477
--- /dev/null
+++ b/PDContainer/src/PDContainer.cpp
@@ -0,0 +1,78 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// PDContainer.cpp 
+
+
+#include "include/GlobalStuff.h"
+
+
+typedef struct PDContainer 
+{
+  t_object x_obj;
+} t_PDContainer;
+
+t_class *PDContainer_class;
+
+static void PDContainer_help(void)
+{
+  post("\nPD-Container, Version: "PDC_VERSION"");
+  post("------------------------------------------");
+  post("this is an implementation of the container");
+  post("objects from the Standard Template");
+  post("Library (STL) of C++");
+  post("for documentation see the help patches");
+  post("(by Georg Holzmann <grh@mur.at>, 2004)");
+  post("------------------------------------------\n");
+}
+
+static void *PDContainer_new(void)
+{
+  t_PDContainer *x = (t_PDContainer *)pd_new(PDContainer_class);
+  return (void *)x;
+}
+
+//-----------------------------------------------------
+// declaration of the setup functions:
+void h_map_setup();
+void h_multimap_setup();
+void h_set_setup();
+void h_multiset_setup();
+void h_vector_setup();
+void h_deque_setup();
+void h_queue_setup();
+void h_priority_queue_setup();
+void h_stack_setup();
+void h_list_setup();
+//-end-of-declaration----------------------------------
+
+extern "C" void PDContainer_setup(void) 
+{
+  //---------------------------------------------------
+  // call all the setup functions:
+  h_map_setup();
+  h_multimap_setup();
+  h_set_setup();
+  h_multiset_setup();
+  h_vector_setup();
+  h_deque_setup();
+  h_queue_setup();
+  h_priority_queue_setup();
+  h_stack_setup();
+  h_list_setup();
+  //-end-----------------------------------------------
+
+  post("\nPD-Container, Version: "PDC_VERSION", by Georg Holzmann <grh@mur.at>, 2004-2005");
+  
+  // without an argument the following two methods wont work ??? why?? because of c++?  
+  PDContainer_class = class_new(gensym("PDContainer"), (t_newmethod)PDContainer_new,
+                                       0, sizeof(t_PDContainer), CLASS_DEFAULT, A_DEFFLOAT,  0);
+  class_addmethod(PDContainer_class, (t_method)PDContainer_help, gensym("help"), A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_deque.cpp b/PDContainer/src/h_deque.cpp
new file mode 100755
index 0000000..6246a51
--- /dev/null
+++ b/PDContainer/src/h_deque.cpp
@@ -0,0 +1,578 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_deque.cpp
+
+
+#include "include/HDeque.h"
+
+
+static t_class *h_deque_class;
+static t_class *proxy_class;
+
+typedef struct _h_deque 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HDeque *hdeque;
+  Element value;
+  bool event_set;
+} t_h_deque;
+
+typedef struct proxy
+{
+  t_object obj;
+  t_int index;  // number of proxy inlet(s)
+  t_h_deque *x;	// we'll put the other struct in here
+} t_proxy;
+
+static void h_deque_set(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_deque, set: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hdeque->getSize() || index < 0 )
+    {
+      post("h_deque, set: invalid index!");
+      return;
+    }
+
+  if(!x->event_set)
+    {
+      post("h_deque, set: you must first set a value at right inlet!");
+      return;
+    }
+  
+  x->hdeque->set( index , x->value); 
+  x->event_set = false;
+}
+
+static void h_deque_insert(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_deque, insert: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hdeque->getSize() || index < 0 )
+    {
+      post("h_deque, insert: invalid index!");
+      return;
+    }
+
+  if(!x->event_set)
+    {
+      post("h_deque, insert: you must first set a value at right inlet!");
+      return;
+    }
+  
+  x->hdeque->insert( index , x->value); 
+  x->event_set = false;
+}
+
+static void h_deque_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
+{
+  t_h_deque *x = (t_h_deque *)(p->x);
+  
+  // symbol without selector "symbol":
+  if(argc == 0)
+  {
+    t_atom tmp;
+    SETSYMBOL(&tmp, s);
+    x->value.setAtoms(1, &tmp);
+    x->event_set = true;
+    return;
+  }
+
+  // input is a list without selector "list":
+  if ( argc && (strcmp(s->s_name,"list")!=0) 
+       && (strcmp(s->s_name,"float")!=0) 
+       && (strcmp(s->s_name,"symbol")!=0)
+       && (strcmp(s->s_name,"pointer")!=0) )
+  {
+    t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
+
+      // add the selector symbol to the list:
+    SETSYMBOL(atoms, s);
+
+    for(int i=0; i<argc; i++)
+    {
+      if(argv[i].a_type == A_FLOAT)
+	SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
+      if(argv[i].a_type == A_SYMBOL)
+	SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
+      if(argv[i].a_type == A_POINTER)
+	SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
+    }
+
+    x->value.setAtoms(argc+1, atoms);
+
+    x->event_set = true;
+    freebytes(atoms, (argc+1)*sizeof(t_atom));
+    return;
+  }
+
+  // "normal" input (list, float or symbol):
+  if (argc)
+  {
+    x->value.setAtoms(argc, argv);
+    x->event_set = true;
+    return;
+  }
+}
+
+static void h_deque_get(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_deque, get: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hdeque->getSize() || index < 0 )
+    {
+      post("h_deque, get: invalid index!");
+      return;
+    }
+
+  Element output = x->hdeque->get( index );
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_deque_push_back(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hdeque->pushBack(key);
+    }
+  else
+    post("h_deque, pushback: no arguments");
+}
+
+static void h_deque_pop_back(t_h_deque *x)
+{
+  if(x->hdeque->getSize()<=0)
+    {
+      post("h_deque, popback: size is already 0 !");
+      return;
+    }
+
+  x->hdeque->popBack();
+}
+
+static void h_deque_back(t_h_deque *x)
+{
+  if(x->hdeque->getSize() == 0)
+    {
+      post("h_deque, back: size is 0 !");
+      return;
+    }
+
+  Element output = x->hdeque->back();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_deque_push_front(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hdeque->pushFront(key);
+    }
+  else
+    post("h_deque, pushfront: no arguments");
+}
+
+static void h_deque_pop_front(t_h_deque *x)
+{
+  if(x->hdeque->getSize()<=0)
+    {
+      post("h_deque, popfront: size is already 0 !");
+      return;
+    }
+
+  x->hdeque->popFront();
+}
+
+static void h_deque_front(t_h_deque *x)
+{
+  if(x->hdeque->getSize() == 0)
+    {
+      post("h_deque, front: size is 0 !");
+      return;
+    }
+
+  Element output = x->hdeque->front();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_deque_remove(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_deque, remove: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hdeque->getSize() || index < 0 )
+    {
+      post("h_deque, remove: invalid index!");
+      return;
+    }
+  
+  x->hdeque->remove(index); 
+  x->event_set = false;
+}
+
+static void h_deque_resize(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int size;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    size = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_deque, resize: invalid index!");
+      return;
+    }
+
+  if ( size < 0 )
+    {
+      post("h_deque, size: invalid size!");
+      return;
+    }
+
+  x->hdeque->resize( size );
+}
+
+static void h_deque_getsize(t_h_deque *x)
+{
+  outlet_float(x->out1,x->hdeque->getSize());
+}
+
+static void h_deque_help(t_h_deque *x)
+{
+  x->hdeque->help();
+}
+
+static void h_deque_set_namespace(t_h_deque *x, t_symbol *s)
+{
+  x->hdeque->setNamespace(s->s_name);
+}
+
+static void h_deque_get_namespace(t_h_deque *x)
+{
+  post("h_deque current namespace: %s",x->hdeque->getNamespace().c_str());
+}
+
+static void h_deque_print(t_h_deque *x)
+{
+  x->hdeque->printAllIndex();
+}
+
+static void h_deque_clear(t_h_deque *x)
+{
+  x->hdeque->clearNamespace();
+}
+
+static void h_deque_clear_all(t_h_deque *x)
+{
+  x->hdeque->clearAll();
+}
+
+static void h_deque_save(t_h_deque *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hdeque->saveToFile(filename))
+    post("h_deque: data of namespace %s written to file %s",
+	 x->hdeque->getNamespace().c_str(),s->s_name);
+  else
+    post("h_deque: couldn't write to file %s",s->s_name);
+}
+
+static void h_deque_read(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hdeque->readFromFile(filename))
+    post("h_deque: couldn't read from file %s",s->s_name);
+}
+
+static void h_deque_read_at(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  string symbol;
+  int index=0;
+
+  switch(argc)
+    {
+    default:
+      post("h_deque read: only two argument are possible!");
+      break;
+    case 2:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = (int)argv[1].a_w.w_float;
+      break; 
+    case 1:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = 0;
+      break;
+    case 0:
+      post("h_deque read: no filename!");
+    }
+
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, (char*)symbol.c_str(), filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hdeque->readFromFile2(filename,index))
+    post("h_deque: couldn't read from file %s",s->s_name);
+}
+
+static void h_deque_save_xml(t_h_deque *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hdeque->saveToFileXML(filename))
+    post("h_deque: data of namespace %s written to file %s",
+         x->hdeque->getNamespace().c_str(),s->s_name);
+  else
+    post("h_deque: couldn't write to file %s",s->s_name);
+}
+
+static void h_deque_read_xml(t_h_deque *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hdeque->readFromFileXML(filename))
+    post("h_deque: couldn't read from file %s",s->s_name);
+}
+
+static void h_deque_read_at_xml(t_h_deque *x, t_symbol *s, int argc, t_atom *argv)
+{
+  string symbol;
+  int index=0;
+
+  switch(argc)
+    {
+    default:
+      post("h_deque read: only two argument are possible!");
+      break;
+    case 2:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = (int)argv[1].a_w.w_float;
+      break; 
+    case 1:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = 0;
+      break;
+    case 0:
+      post("h_deque read: no filename!");
+    }
+
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, (char*)symbol.c_str(), filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hdeque->readFromFile2XML(filename,index))
+    post("h_deque: couldn't read from file %s",s->s_name);
+}
+
+static void *h_deque_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_deque *x = (t_h_deque *)pd_new(h_deque_class);
+  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet
+
+  inlet->x = x;	// make x visible to the proxy inlets
+  
+  switch(argc)
+    {
+    default:
+      post("h_deque warning: only one argument for namespace is possible!");
+   case 1:
+      x->hdeque = new HDeque(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hdeque = new HDeque();
+      break;
+    }
+
+  // we are going to create a proxy inlet no. 0
+  // it belongs to the object x but the destination is t_proxy
+  inlet->index = 0;
+  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_deque_free(t_h_deque *x)
+{
+  delete x->hdeque;
+  return (void *)x;
+}
+
+void h_deque_setup(void) 
+{
+  // the object class
+  h_deque_class = class_new(gensym("h_deque"), (t_newmethod)h_deque_new,
+				(t_method)h_deque_free, sizeof(t_h_deque), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  // a class for the proxy-inlet
+  proxy_class = class_new(gensym("h_deque_proxy"), NULL, NULL, sizeof(t_proxy),
+			  CLASS_PD|CLASS_NOINLET, A_NULL);
+
+  class_addmethod(h_deque_class, (t_method)h_deque_set, 
+		  gensym("set"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_insert, 
+		  gensym("insert"), A_GIMME, 0);
+  class_addanything(proxy_class, (t_method)h_deque_value); // the right inlet
+  class_addmethod(h_deque_class, (t_method)h_deque_get, 
+		  gensym("get"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_push_back, 
+		  gensym("pushback"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_pop_back, 
+		  gensym("popback"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_back, 
+		  gensym("back"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_push_front, 
+		  gensym("pushfront"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_pop_front, 
+		  gensym("popfront"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_front, 
+		  gensym("front"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_remove, 
+		  gensym("remove"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_resize, 
+		  gensym("resize"), A_GIMME , 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_save, 
+		  gensym("save"), A_DEFSYMBOL, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_read, 
+		  gensym("read"), A_DEFSYMBOL, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_read_at, 
+		  gensym("readat"), A_GIMME, 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_deque_class, (t_method)h_deque_read_at_xml, 
+		  gensym("readatXML"), A_GIMME, 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_deque_class, (t_method)h_deque_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_list.cpp b/PDContainer/src/h_list.cpp
new file mode 100755
index 0000000..bbe9b68
--- /dev/null
+++ b/PDContainer/src/h_list.cpp
@@ -0,0 +1,442 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_list.cpp
+
+
+#include "include/HList.h"
+
+
+static t_class *h_list_class;
+
+typedef struct _h_list 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2, *out3;
+  HList *hlist;
+} t_h_list;
+
+static void h_list_push_back(t_h_list *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hlist->pushBack(key);
+    }
+  else
+    post("h_list, pushback: no arguments");
+}
+
+static void h_list_pop_back(t_h_list *x)
+{
+  if(x->hlist->getSize()<=0)
+    {
+      post("h_list, popback: size is 0 !");
+      return;
+    }
+
+  x->hlist->popBack();
+}
+
+static void h_list_push_front(t_h_list *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hlist->pushFront(key);
+    }
+  else
+    post("h_list, pushfront: no arguments");
+}
+
+static void h_list_pop_front(t_h_list *x)
+{
+  if(x->hlist->getSize()<=0)
+    {
+      post("h_list, popfront: size is 0 !");
+      return;
+    }
+
+  x->hlist->popFront();
+}
+
+static void h_list_back(t_h_list *x)
+{
+  if(x->hlist->getSize() == 0)
+    {
+      outlet_bang(x->out3);
+      return;
+    }
+
+  Element output = x->hlist->back();
+ 
+  if(output.getLength() == 1) // symbol, float or pointer
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  outlet_bang(x->out3);
+}
+
+static void h_list_front(t_h_list *x)
+{
+  if(x->hlist->getSize() == 0)
+    {
+      outlet_bang(x->out3);
+      return;
+    }
+
+  Element output = x->hlist->front();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+    
+  outlet_bang(x->out3);
+}
+
+static void h_list_get(t_h_list *x)
+{
+  if(x->hlist->getSize() == 0)
+    {
+      outlet_bang(x->out3);
+      return;
+    }
+
+  Element output;
+
+  try
+  { output = x->hlist->get(); }
+  
+  catch(const char* s)
+  {
+    // if there was no Element found, put out a bang at the right outlet
+    post("%s", s);
+    outlet_bang(x->out3);
+    return;
+  }
+
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  outlet_bang(x->out3);
+}
+
+static void h_list_insert(t_h_list *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hlist->insert(key);
+    }
+  else
+    post("h_list, insert: no arguments");
+}
+
+static void h_list_modify(t_h_list *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+  {
+    Element key(argc,argv);
+    x->hlist->modify(key);
+  }
+  else
+    post("h_list, modify: no arguments");
+}
+
+static void h_list_remove(t_h_list *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hlist->remove(key);
+    }
+  else
+    post("h_list, remove: no arguments");
+}
+
+static void h_list_delete(t_h_list *x)
+{
+  x->hlist->del();
+}
+
+static void h_list_begin(t_h_list *x)
+{
+  x->hlist->begin();
+}
+
+static void h_list_end(t_h_list *x)
+{
+  x->hlist->end();
+}
+
+static void h_list_next(t_h_list *x)
+{
+  x->hlist->next();
+}
+
+static void h_list_last(t_h_list *x)
+{
+  x->hlist->last();
+}
+
+static void h_list_unique(t_h_list *x)
+{
+  x->hlist->unique();
+}
+
+static void h_list_reverse(t_h_list *x)
+{
+  x->hlist->reverse();
+}
+
+static void h_list_sort(t_h_list *x)
+{
+  x->hlist->sort();
+}
+
+static void h_list_getsize(t_h_list *x)
+{
+  outlet_float(x->out2,x->hlist->getSize());
+}
+
+static void h_list_get_iter_pos(t_h_list *x)
+{
+  outlet_float(x->out1,x->hlist->getIterPos());
+}
+
+static void h_list_set_iter_pos(t_h_list *x, t_floatarg f)
+{
+  x->hlist->setIterPos(static_cast<int>(f));
+}
+
+static void h_list_help(t_h_list *x)
+{
+  x->hlist->help();
+}
+
+static void h_list_set_namespace(t_h_list *x, t_symbol *s)
+{
+  x->hlist->setNamespace(s->s_name);
+}
+
+static void h_list_get_namespace(t_h_list *x)
+{
+  post("h_list current namespace: %s",x->hlist->getNamespace().c_str());
+}
+
+static void h_list_clear(t_h_list *x)
+{
+  x->hlist->clearNamespace();
+}
+
+static void h_list_clear_all(t_h_list *x)
+{
+  x->hlist->clearAll();
+}
+
+static void h_list_print(t_h_list *x)
+{
+  x->hlist->printAllIndex();
+}
+
+static void h_list_save(t_h_list *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hlist->saveToFile(filename))
+    post("h_list: data of namespace %s written to file %s",
+	 x->hlist->getNamespace().c_str(),s->s_name);
+  else
+    post("h_list: couldn't write to file %s",s->s_name);
+}
+
+static void h_list_read(t_h_list *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hlist->readFromFile(filename))
+    post("h_list: couldn't read from file %s",s->s_name);
+}
+
+static void h_list_save_xml(t_h_list *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hlist->saveToFileXML(filename))
+    post("h_list: data of namespace %s written to file %s",
+         x->hlist->getNamespace().c_str(),s->s_name);
+  else
+    post("h_list: couldn't write to file %s",s->s_name);
+}
+
+static void h_list_read_xml(t_h_list *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hlist->readFromFileXML(filename))
+    post("h_list: couldn't read from file %s",s->s_name);
+}
+
+static void *h_list_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_list *x = (t_h_list *)pd_new(h_list_class);
+  
+  switch(argc)
+    {
+    default:
+      post("h_list warning: only one argument for namespace is possible!");
+   case 1:
+      x->hlist = new HList(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hlist = new HList();
+      break;
+    }
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_float);
+  x->out3 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_list_free(t_h_list *x)
+{
+  delete x->hlist;
+  return (void *)x;
+}
+
+void h_list_setup(void) 
+{
+  // the object class
+  h_list_class = class_new(gensym("h_list"), (t_newmethod)h_list_new,
+				(t_method)h_list_free, sizeof(t_h_list), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  class_addmethod(h_list_class, (t_method)h_list_push_back, 
+		  gensym("pushback"), A_GIMME, 0);
+  class_addmethod(h_list_class, (t_method)h_list_pop_back, 
+		  gensym("popback"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_push_front, 
+		  gensym("pushfront"), A_GIMME, 0);
+  class_addmethod(h_list_class, (t_method)h_list_pop_front, 
+		  gensym("popfront"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_back, 
+		  gensym("back"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_front, 
+		  gensym("front"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_get, 
+		  gensym("get"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_insert, 
+		  gensym("insert"), A_GIMME, 0);
+  class_addmethod(h_list_class, (t_method)h_list_modify, 
+      gensym("modify"), A_GIMME, 0);
+  class_addmethod(h_list_class, (t_method)h_list_remove, 
+		  gensym("remove"), A_GIMME, 0);
+  class_addmethod(h_list_class, (t_method)h_list_delete, 
+		  gensym("delete"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_list_class, (t_method)h_list_get_iter_pos, 
+		  gensym("getiter"), A_DEFFLOAT , 0);
+  class_addmethod(h_list_class, (t_method)h_list_set_iter_pos, 
+		  gensym("setiter"), A_DEFFLOAT , 0);
+  class_addmethod(h_list_class, (t_method)h_list_begin, 
+		  gensym("begin"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_end, 
+		  gensym("end"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_next, 
+		  gensym("next"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_last, 
+		  gensym("last"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_unique, 
+		  gensym("unique"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_reverse, 
+		  gensym("reverse"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_sort, 
+		  gensym("sort"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_list_class, (t_method)h_list_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_list_class, (t_method)h_list_save, 
+		  gensym("save"), A_DEFSYMBOL , 0);
+  class_addmethod(h_list_class, (t_method)h_list_read, 
+		  gensym("read"), A_DEFSYMBOL , 0);
+  class_addmethod(h_list_class, (t_method)h_list_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_list_class, (t_method)h_list_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_list_class, (t_method)h_list_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_map.cpp b/PDContainer/src/h_map.cpp
new file mode 100755
index 0000000..11ce59e
--- /dev/null
+++ b/PDContainer/src/h_map.cpp
@@ -0,0 +1,334 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_map.cpp
+
+
+#include "include/HMap.h"
+
+
+static t_class *h_map_class;
+static t_class *proxy_class;
+
+typedef struct _h_map 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HMap *hmap;
+  Element value;
+  bool event_set;
+} t_h_map;
+
+typedef struct proxy
+{
+  t_object obj;
+  t_int index;  // number of proxy inlet(s)
+  t_h_map *x;	// we'll put the other struct in here
+} t_proxy;
+
+static void h_map_add(t_h_map *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!x->event_set)
+    {
+      post("h_map, add: you must first set a value at right inlet!");
+      return;
+    }
+  
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hmap->add(key, x->value);
+      x->event_set = false;
+    }
+  else
+    post("h_map, add: no arguments"); 
+}
+
+static void h_map_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
+{
+  t_h_map *x = (t_h_map *)(p->x);
+
+  // symbol without selector "symbol":
+  if(argc == 0)
+    {
+      t_atom tmp;
+      SETSYMBOL(&tmp, s);
+      x->value.setAtoms(1, &tmp);
+      x->event_set = true;
+      return;
+    }
+
+  // input is a list without selector "list":
+  if ( argc && (strcmp(s->s_name,"list")!=0) 
+       && (strcmp(s->s_name,"float")!=0) 
+       && (strcmp(s->s_name,"symbol")!=0)
+       && (strcmp(s->s_name,"pointer")!=0) )
+    {
+      t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
+
+      // add the selector symbol to the list:
+      SETSYMBOL(atoms, s);
+
+      for(int i=0; i<argc; i++)
+      {
+	if(argv[i].a_type == A_FLOAT)
+	  SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
+	if(argv[i].a_type == A_SYMBOL)
+	  SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
+	if(argv[i].a_type == A_POINTER)
+	  SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
+      }
+
+      x->value.setAtoms(argc+1, atoms);
+
+      x->event_set = true;
+      freebytes(atoms, (argc+1)*sizeof(t_atom));
+      return;
+    }
+
+  // "normal" input (list, float, symbol or pointer):
+  if (argc)
+    {
+      x->value.setAtoms(argc, argv);
+      x->event_set = true;
+      return;
+    }
+}
+
+static void h_map_get(t_h_map *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_map, get: no arguments"); 
+      return;
+    }
+
+  Element key(argc,argv);
+  Element output;
+
+  try
+  { output = x->hmap->get( key ); }
+
+  catch(const char* s)
+  {
+    // if there was no Element found, put out a bang at the right outlet
+    post("%s", s);
+    outlet_bang(x->out2);
+    return;
+  }
+
+  if(output.getLength() == 1) // symbol, float or pointer
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_map_remove(t_h_map *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_map, remove: no arguments"); 
+      return;
+    }
+
+  Element key(argc,argv);
+
+  try
+  { x->hmap->remove( key ); }
+
+  catch(const char* s)
+  { post("%s", s); }
+}
+
+static void h_map_getsize(t_h_map *x)
+{
+  outlet_float(x->out1,x->hmap->getSize());
+}
+
+static void h_map_help(t_h_map *x)
+{
+  x->hmap->help();
+}
+
+static void h_map_set_namespace(t_h_map *x, t_symbol *s)
+{
+  x->hmap->setNamespace(s->s_name);
+}
+
+static void h_map_get_namespace(t_h_map *x)
+{
+  post("h_map current namespace: %s",x->hmap->getNamespace().c_str());
+}
+
+static void h_map_print(t_h_map *x)
+{
+  x->hmap->printAll();
+}
+
+static void h_map_clear(t_h_map *x)
+{
+  x->hmap->clearNamespace();
+}
+
+static void h_map_clear_all(t_h_map *x)
+{
+  x->hmap->clearAll();
+}
+
+static void h_map_save(t_h_map *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmap->saveToFile(filename))
+    post("h_map: data of namespace %s written to file %s",
+	 x->hmap->getNamespace().c_str(),s->s_name);
+  else
+    post("h_map: couldn't write to file %s",s->s_name);
+}
+
+static void h_map_save_xml(t_h_map *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmap->saveToFileXML(filename))
+    post("h_map: data of namespace %s written to file %s",
+	 x->hmap->getNamespace().c_str(),s->s_name);
+  else
+    post("h_map: couldn't write to file %s",s->s_name);
+}
+
+static void h_map_read(t_h_map *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmap->readFromFile(filename))
+    post("h_map: couldn't read from file %s",s->s_name);
+}
+
+static void h_map_read_xml(t_h_map *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmap->readFromFileXML(filename))
+    post("h_map: couldn't read from file %s",s->s_name);
+}
+
+static void *h_map_new(t_symbol *s, int argc, t_atom *argv) 
+{
+
+  t_h_map *x = (t_h_map *)pd_new(h_map_class);
+  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet
+
+  inlet->x = x;	// make x visible to the proxy inlets
+  
+  switch(argc)
+    {
+    default:
+      post("h_map warning: only one argument for namespace is possible!");
+    case 1:
+      x->hmap = new HMap(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hmap = new HMap();
+      break;
+    }
+
+  // we are going to create a proxy inlet no. 0
+  // it belongs to the object x but the destination is t_proxy
+  inlet->index = 0;
+  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_map_free(t_h_map *x)
+{
+  delete x->hmap;
+  return (void *)x;
+}
+
+void h_map_setup(void) 
+{
+  // the object class
+  h_map_class = class_new(gensym("h_map"), (t_newmethod)h_map_new,
+				(t_method)h_map_free, sizeof(t_h_map), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  // a class for the proxy-inlet
+  proxy_class = class_new(gensym("h_map_proxy"), NULL, NULL, sizeof(t_proxy),
+			  CLASS_PD|CLASS_NOINLET, A_NULL);
+
+  class_addmethod(h_map_class, (t_method)h_map_add, 
+		  gensym("add"), A_GIMME , 0);
+  class_addanything(proxy_class, (t_method)h_map_value); // the right inlet
+  class_addmethod(h_map_class, (t_method)h_map_get, 
+		  gensym("get"), A_GIMME , 0);
+  class_addmethod(h_map_class, (t_method)h_map_remove, 
+		  gensym("remove"), A_GIMME , 0);
+  class_addmethod(h_map_class, (t_method)h_map_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_map_class, (t_method)h_map_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_map_class, (t_method)h_map_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_map_class, (t_method)h_map_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_map_class, (t_method)h_map_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_map_class, (t_method)h_map_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_map_class, (t_method)h_map_save, 
+		  gensym("save"), A_DEFSYMBOL , 0);
+  class_addmethod(h_map_class, (t_method)h_map_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_map_class, (t_method)h_map_read, 
+		  gensym("read"), A_DEFSYMBOL , 0);
+  class_addmethod(h_map_class, (t_method)h_map_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_map_class, (t_method)h_map_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_multimap.cpp b/PDContainer/src/h_multimap.cpp
new file mode 100755
index 0000000..8449fd9
--- /dev/null
+++ b/PDContainer/src/h_multimap.cpp
@@ -0,0 +1,331 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_multimap.cpp
+
+
+#include "include/HMultiMap.h"
+
+
+static t_class *h_multimap_class;
+static t_class *proxy_class;
+
+typedef struct _h_multimap 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HMultiMap *hmultimap;
+  Element value;
+  bool event_set;
+} t_h_multimap;
+
+typedef struct proxy
+{
+  t_object obj;
+  t_int index;      // number of proxy inlet(s)
+  t_h_multimap *x;  // we'll put the other struct in here
+} t_proxy;
+
+static void h_multimap_add(t_h_multimap *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!x->event_set)
+    {
+      post("h_multimap, add: you must first set a value at right inlet!");
+      return;
+    }
+  
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hmultimap->add(key, x->value);
+      x->event_set = false;
+    }
+  else
+    post("h_multimap, add: no arguments"); 
+}
+
+static void h_multimap_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
+{
+  t_h_multimap *x = (t_h_multimap *)(p->x);
+
+  // symbol without selector "symbol":
+  if(argc == 0)
+  {
+    t_atom tmp;
+    SETSYMBOL(&tmp, s);
+    x->value.setAtoms(1, &tmp);
+    x->event_set = true;
+    return;
+  }
+
+  // input is a list without selector "list":
+    // input is a list without selector "list":
+  if ( argc && (strcmp(s->s_name,"list")!=0) 
+       && (strcmp(s->s_name,"float")!=0) 
+       && (strcmp(s->s_name,"symbol")!=0)
+       && (strcmp(s->s_name,"pointer")!=0) )
+  {
+    t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
+
+      // add the selector symbol to the list:
+    SETSYMBOL(atoms, s);
+
+    for(int i=0; i<argc; i++)
+    {
+      if(argv[i].a_type == A_FLOAT)
+	SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
+      if(argv[i].a_type == A_SYMBOL)
+	SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
+      if(argv[i].a_type == A_POINTER)
+	SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
+    }
+
+    x->value.setAtoms(argc+1, atoms);
+
+    x->event_set = true;
+    freebytes(atoms, (argc+1)*sizeof(t_atom));
+    return;
+  }
+
+  // "normal" input (list, float, symbol or pointer):
+  if (argc)
+  {
+    x->value.setAtoms(argc, argv);
+    x->event_set = true;
+    return;
+  }
+}
+
+static void h_multimap_get(t_h_multimap *x, t_symbol *s,  int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_multimap, get: no arguments"); 
+      return;
+    }  
+  
+  // outputs all the values of one key one after an other
+
+  Element key(argc,argv);
+  int value_nr = x->hmultimap->getNr( key );
+
+  outlet_float(x->out1,value_nr);
+
+  for(int i=0; i < value_nr; i++)
+    {
+      Element output;
+      try
+      { output = x->hmultimap->get(key, i); }
+      catch(const char* s)
+      {
+	post("%s", s);
+	continue;
+      }
+
+      if(output.getLength() == 1) // symbol, float or pointer
+	{
+	  if (output.getAtom()[0].a_type == A_FLOAT)
+	    outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+	  if (output.getAtom()[0].a_type == A_SYMBOL)
+	    outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+	  if (output.getAtom()[0].a_type == A_POINTER)
+	    outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+	}
+      if(output.getLength() > 1) // list
+	outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+    }
+}
+
+static void h_multimap_remove(t_h_multimap *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_multimap, remove: no arguments"); 
+      return;
+    }  
+  
+  Element key(argc,argv);
+  try
+  { x->hmultimap->remove( key ); }
+  catch(const char* s)
+  { post("%s", s); }
+}
+
+static void h_multimap_getsize(t_h_multimap *x)
+{
+  outlet_float(x->out2,x->hmultimap->getSize());
+}
+
+static void h_multimap_help(t_h_multimap *x)
+{
+  x->hmultimap->help();
+}
+
+static void h_multimap_set_namespace(t_h_multimap *x, t_symbol *s)
+{
+  x->hmultimap->setNamespace(s->s_name);
+}
+
+static void h_multimap_get_namespace(t_h_multimap *x)
+{
+  post("h_multimap current namespace: %s",x->hmultimap->getNamespace().c_str());
+}
+
+static void h_multimap_print(t_h_multimap *x)
+{
+  x->hmultimap->printAll();
+}
+
+static void h_multimap_clear(t_h_multimap *x)
+{
+  x->hmultimap->clearNamespace();
+}
+
+static void h_multimap_clear_all(t_h_multimap *x)
+{
+  x->hmultimap->clearAll();
+}
+
+static void h_multimap_save(t_h_multimap *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmultimap->saveToFile(filename))
+    post("h_multimap: data of namespace %s written to file %s",
+	 x->hmultimap->getNamespace().c_str(),s->s_name);
+  else
+    post("h_multimap: couldn't write to file %s",s->s_name);
+}
+
+static void h_multimap_save_xml(t_h_multimap *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmultimap->saveToFileXML(filename))
+    post("h_multimap: data of namespace %s written to file %s",
+         x->hmultimap->getNamespace().c_str(),s->s_name);
+  else
+    post("h_multimap: couldn't write to file %s",s->s_name);
+}
+
+static void h_multimap_read(t_h_multimap *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmultimap->readFromFile(filename))
+    post("h_multimap: couldn't read from file %s",s->s_name);
+}
+
+static void h_multimap_read_xml(t_h_multimap *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmultimap->readFromFileXML(filename))
+    post("h_multimap: couldn't read from file %s",s->s_name);
+}
+
+static void *h_multimap_new(t_symbol *s, int argc, t_atom *argv) 
+{
+
+  t_h_multimap *x = (t_h_multimap *)pd_new(h_multimap_class);
+  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet
+
+  inlet->x = x;	// make x visible to the proxy inlets
+  
+  switch(argc)
+    {
+    default:
+      post("h_multimap warning: only one argument for namespace is possible!");
+    case 1:
+      x->hmultimap = new HMultiMap(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hmultimap = new HMultiMap();
+      break;
+    }
+
+  // we are going to create a proxy inlet no. 0
+  // it belongs to the object x but the destination is t_proxy
+  inlet->index = 0;
+  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_float);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_multimap_free(t_h_multimap *x)
+{
+  delete x->hmultimap;
+  return (void *)x;
+}
+
+void h_multimap_setup(void) 
+{
+  h_multimap_class = class_new(gensym("h_multimap"), (t_newmethod)h_multimap_new,
+				(t_method)h_multimap_free, sizeof(t_h_multimap), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  // a class for the proxy-inlet
+  proxy_class = class_new(gensym("h_map_proxy"), NULL, NULL, sizeof(t_proxy),
+			  CLASS_PD|CLASS_NOINLET, A_NULL);
+
+  class_addmethod(h_multimap_class, (t_method)h_multimap_add, 
+		  gensym("add"), A_GIMME , 0);
+  class_addanything(proxy_class, (t_method)h_multimap_value); // the right inlet
+  class_addmethod(h_multimap_class, (t_method)h_multimap_get, 
+		  gensym("get"), A_GIMME , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_remove, 
+		  gensym("remove"), A_GIMME , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_save, 
+		  gensym("save"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_save_xml, 
+      gensym("saveXML"), A_DEFSYMBOL , 0);  
+  class_addmethod(h_multimap_class, (t_method)h_multimap_read, 
+		  gensym("read"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multimap_class, (t_method)h_multimap_read_xml, 
+      gensym("readXML"), A_DEFSYMBOL , 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_multimap_class, (t_method)h_multimap_help, 
+		  gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_multiset.cpp b/PDContainer/src/h_multiset.cpp
new file mode 100755
index 0000000..0886a8b
--- /dev/null
+++ b/PDContainer/src/h_multiset.cpp
@@ -0,0 +1,220 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_multiset.cpp
+
+
+#include "include/HMultiSet.h"
+
+
+static t_class *h_multiset_class;
+
+typedef struct _h_multiset 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1;
+  HMultiSet *hmultiset;
+} t_h_multiset;
+
+static void h_multiset_add(t_h_multiset *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_multiset, add: no arguments"); 
+      return;
+    }
+  
+  Element key(argc,argv);
+  x->hmultiset->add( key );
+}
+
+static void h_multiset_get(t_h_multiset *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_multiset, get: no arguments"); 
+      return;
+    }  
+  
+  Element key(argc,argv);
+  int output = x->hmultiset->get( key );
+
+  outlet_float(x->out0, output);
+}
+
+static void h_multiset_remove(t_h_multiset *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_multiset, remove: no arguments"); 
+      return;
+    }  
+  
+  Element key(argc,argv);
+  x->hmultiset->remove( key );
+}
+
+static void h_multiset_getsize(t_h_multiset *x)
+{
+  outlet_float(x->out1,x->hmultiset->getSize());
+}
+
+static void h_multiset_help(t_h_multiset *x)
+{
+  x->hmultiset->help();
+}
+
+static void h_multiset_set_namespace(t_h_multiset *x, t_symbol *s)
+{
+  x->hmultiset->setNamespace(s->s_name);
+}
+
+static void h_multiset_get_namespace(t_h_multiset *x)
+{
+  post("h_multiset current namespace: %s",x->hmultiset->getNamespace().c_str());
+}
+
+static void h_multiset_print(t_h_multiset *x)
+{
+  x->hmultiset->printAll();
+}
+
+static void h_multiset_clear(t_h_multiset *x)
+{
+  x->hmultiset->clearNamespace();
+}
+
+static void h_multiset_clear_all(t_h_multiset *x)
+{
+  x->hmultiset->clearAll();
+}
+
+static void h_multiset_save(t_h_multiset *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmultiset->saveToFile(filename))
+    post("h_multiset: data of namespace %s written to file %s",
+	 x->hmultiset->getNamespace().c_str(),s->s_name);
+  else
+    post("h_multiset: couldn't write to file %s",s->s_name);
+}
+
+static void h_multiset_read(t_h_multiset *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmultiset->readFromFile(filename))
+    post("h_multiset: couldn't read from file %s",s->s_name);
+}
+
+static void h_multiset_save_xml(t_h_multiset *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hmultiset->saveToFileXML(filename))
+    post("h_multiset: data of namespace %s written to file %s",
+         x->hmultiset->getNamespace().c_str(),s->s_name);
+  else
+    post("h_multiset: couldn't write to file %s",s->s_name);
+}
+
+static void h_multiset_read_xml(t_h_multiset *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hmultiset->readFromFileXML(filename))
+    post("h_multiset: couldn't read from file %s",s->s_name);
+}
+
+static void *h_multiset_new(t_symbol *s, int argc, t_atom *argv) 
+{
+
+  t_h_multiset *x = (t_h_multiset *)pd_new(h_multiset_class);
+  
+  switch(argc)
+    {
+    default:
+      post("h_multiset warning: only one argument for namespace is possible!");
+    case 1:
+      x->hmultiset = new HMultiSet(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hmultiset = new HMultiSet();
+      break;
+    }
+
+  x->out0 = outlet_new(&x->x_obj, &s_float);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_multiset_free(t_h_multiset *x)
+{
+  delete x->hmultiset;
+  return (void *)x;
+}
+
+void h_multiset_setup(void) 
+{
+  // the object class
+  h_multiset_class = class_new(gensym("h_multiset"), (t_newmethod)h_multiset_new,
+				(t_method)h_multiset_free, sizeof(t_h_multiset), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  class_addmethod(h_multiset_class, (t_method)h_multiset_add, 
+		  gensym("add"), A_GIMME , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_get, 
+		  gensym("get"), A_GIMME , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_remove, 
+		  gensym("remove"), A_GIMME , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_save, 
+		  gensym("save"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_read, 
+		  gensym("read"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_multiset_class, (t_method)h_multiset_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_multiset_class, (t_method)h_multiset_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_prioqueue.cpp b/PDContainer/src/h_prioqueue.cpp
new file mode 100755
index 0000000..9f770ed
--- /dev/null
+++ b/PDContainer/src/h_prioqueue.cpp
@@ -0,0 +1,250 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_prioqueue.cpp
+
+
+#include "include/HPrioQueue.h"
+
+
+static t_class *h_priority_queue_class;
+static t_class *proxy_class;
+
+typedef struct _h_priority_queue 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HPrioQueue *hpriority_queue;
+  Element value;
+  bool event_set;
+} t_h_priority_queue;
+
+typedef struct proxy
+{
+  t_object obj;
+  t_int index;  // number of proxy inlet(s)
+  t_h_priority_queue *x;	// we'll put the other struct in here
+} t_proxy;
+
+static void h_priority_queue_push(t_h_priority_queue *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!x->event_set)
+    {
+      post("h_priority_queue, insert: you must first set a value at right inlet!");
+      return;
+    }
+
+  float prio;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    prio = static_cast<float>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_priority_queue, push: invalid priority!");
+      return;
+    }
+
+  x->hpriority_queue->push(prio,x->value);
+  x->event_set = false;
+}
+
+static void h_priority_queue_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
+{
+  t_h_priority_queue *x = (t_h_priority_queue *)(p->x);
+
+  // symbol without selector "symbol":
+  if(argc == 0)
+  {
+    t_atom tmp;
+    SETSYMBOL(&tmp, s);
+    x->value.setAtoms(1, &tmp);
+    x->event_set = true;
+    return;
+  }
+
+  // input is a list without selector "list":
+  if ( argc && (strcmp(s->s_name,"list")!=0) 
+       && (strcmp(s->s_name,"float")!=0) 
+       && (strcmp(s->s_name,"symbol")!=0)
+       && (strcmp(s->s_name,"pointer")!=0) )
+  {
+    t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
+
+      // add the selector symbol to the list:
+    SETSYMBOL(atoms, s);
+
+    for(int i=0; i<argc; i++)
+    {
+      if(argv[i].a_type == A_FLOAT)
+	SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
+      if(argv[i].a_type == A_SYMBOL)
+	SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
+      if(argv[i].a_type == A_POINTER)
+	SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
+    }
+
+    x->value.setAtoms(argc+1, atoms);
+
+    x->event_set = true;
+    freebytes(atoms, (argc+1)*sizeof(t_atom));
+    return;
+  }
+
+  // "normal" input (list, float, pointer or symbol):
+  if (argc)
+  {
+    x->value.setAtoms(argc, argv);
+    x->event_set = true;
+    return;
+  }
+}
+
+static void h_priority_queue_top(t_h_priority_queue *x)
+{
+  if(x->hpriority_queue->getSize()==0)
+    {
+      // if there was no Element found, put out a bang at the right outlet
+      outlet_bang(x->out2);
+      return;
+    }
+
+  Element output = x->hpriority_queue->top();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_priority_queue_pop(t_h_priority_queue *x)
+{
+  if(x->hpriority_queue->getSize()<=0)
+    {
+      post("h_priority_queue, pop: size is already 0 !");
+      return;
+    }
+
+  x->hpriority_queue->pop();
+}
+
+static void h_priority_queue_getsize(t_h_priority_queue *x)
+{
+  outlet_float(x->out1,x->hpriority_queue->getSize());
+}
+
+static void h_priority_queue_help(t_h_priority_queue *x)
+{
+  x->hpriority_queue->help();
+}
+
+static void h_priority_queue_set_namespace(t_h_priority_queue *x, t_symbol *s)
+{
+  x->hpriority_queue->setNamespace(s->s_name);
+}
+
+static void h_priority_queue_get_namespace(t_h_priority_queue *x)
+{
+  post("h_priority_queue current namespace: %s",x->hpriority_queue->getNamespace().c_str());
+}
+
+static void h_priority_queue_clear(t_h_priority_queue *x)
+{
+  x->hpriority_queue->clearNamespace();
+}
+
+static void h_priority_queue_clear_all(t_h_priority_queue *x)
+{
+  x->hpriority_queue->clearAll();
+}
+
+static void *h_priority_queue_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_priority_queue *x = (t_h_priority_queue *)pd_new(h_priority_queue_class);
+  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet
+
+  inlet->x = x;	// make x visible to the proxy inlets
+  
+  switch(argc)
+    {
+    default:
+      post("h_priority_queue warning: only one argument for namespace is possible!");
+   case 1:
+      x->hpriority_queue = new HPrioQueue(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hpriority_queue = new HPrioQueue();
+      break;
+    }
+
+  // we are going to create a proxy inlet no. 0
+  // it belongs to the object x but the destination is t_proxy
+  inlet->index = 0;
+  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_priority_queue_free(t_h_priority_queue *x)
+{
+  delete x->hpriority_queue;
+  return (void *)x;
+}
+
+void h_priority_queue_setup(void) 
+{
+  // the object class
+  h_priority_queue_class = class_new(gensym("h_priority_queue"), (t_newmethod)h_priority_queue_new,
+				(t_method)h_priority_queue_free, sizeof(t_h_priority_queue), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  // a class for the proxy-inlet
+  proxy_class = class_new(gensym("h_priority_queue_proxy"), NULL, NULL, sizeof(t_proxy),
+			  CLASS_PD|CLASS_NOINLET, A_NULL);
+
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_push, 
+		  gensym("push"), A_GIMME, 0);
+  class_addanything(proxy_class, (t_method)h_priority_queue_value); // the right inlet
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_pop, 
+		  gensym("pop"), A_DEFFLOAT, 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_top, 
+		  gensym("top"), A_DEFFLOAT, 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_priority_queue_class, (t_method)h_priority_queue_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_queue.cpp b/PDContainer/src/h_queue.cpp
new file mode 100755
index 0000000..77d5ef7
--- /dev/null
+++ b/PDContainer/src/h_queue.cpp
@@ -0,0 +1,165 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_queue.cpp
+
+
+#include "include/HQueue.h"
+
+
+static t_class *h_queue_class;
+
+typedef struct _h_queue 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HQueue *hqueue;
+} t_h_queue;
+
+static void h_queue_push(t_h_queue *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hqueue->push(key);
+    }
+  else
+    post("h_queue, push: no arguments");
+}
+
+static void h_queue_pop(t_h_queue *x)
+{
+  if(x->hqueue->getSize()<=0)
+    {
+      post("h_queue, pop: size is 0 !");
+      return;
+    }
+
+  x->hqueue->pop();
+}
+
+static void h_queue_front(t_h_queue *x)
+{
+  if(x->hqueue->getSize() == 0)
+    {
+      outlet_bang(x->out2);
+      return;
+    }
+
+  Element output = x->hqueue->front();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+    
+  // outlet bang if no data here
+  outlet_bang(x->out2);
+}
+
+static void h_queue_getsize(t_h_queue *x)
+{
+  outlet_float(x->out1,x->hqueue->getSize());
+}
+
+static void h_queue_help(t_h_queue *x)
+{
+  x->hqueue->help();
+}
+
+static void h_queue_set_namespace(t_h_queue *x, t_symbol *s)
+{
+  x->hqueue->setNamespace(s->s_name);
+}
+
+static void h_queue_get_namespace(t_h_queue *x)
+{
+  post("h_queue current namespace: %s",x->hqueue->getNamespace().c_str());
+}
+
+static void h_queue_clear(t_h_queue *x)
+{
+  x->hqueue->clearNamespace();
+}
+
+static void h_queue_clear_all(t_h_queue *x)
+{
+  x->hqueue->clearAll();
+}
+
+static void *h_queue_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_queue *x = (t_h_queue *)pd_new(h_queue_class);
+  
+  switch(argc)
+    {
+    default:
+      post("h_queue warning: only one argument for namespace is possible!");
+   case 1:
+      x->hqueue = new HQueue(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hqueue = new HQueue();
+      break;
+    }
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_queue_free(t_h_queue *x)
+{
+  delete x->hqueue;
+  return (void *)x;
+}
+
+void h_queue_setup(void) 
+{
+  // the object class
+  h_queue_class = class_new(gensym("h_queue"), (t_newmethod)h_queue_new,
+				(t_method)h_queue_free, sizeof(t_h_queue), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  class_addmethod(h_queue_class, (t_method)h_queue_push, 
+		  gensym("push"), A_GIMME, 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_pop, 
+		  gensym("pop"), A_DEFFLOAT, 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_front, 
+		  gensym("front"), A_DEFFLOAT, 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_queue_class, (t_method)h_queue_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_queue_class, (t_method)h_queue_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_set.cpp b/PDContainer/src/h_set.cpp
new file mode 100755
index 0000000..2e97cef
--- /dev/null
+++ b/PDContainer/src/h_set.cpp
@@ -0,0 +1,220 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_set.cpp
+
+
+#include "include/HSet.h"
+
+
+static t_class *h_set_class;
+
+typedef struct _h_set 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1;
+  HSet *hset;
+} t_h_set;
+
+static void h_set_add(t_h_set *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_set, add: no arguments"); 
+      return;
+    }
+  
+  Element key(argc,argv);
+  x->hset->add( key );
+}
+
+static void h_set_get(t_h_set *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_set, get: no arguments"); 
+      return;
+    }  
+  
+  Element key(argc,argv);
+  int output = x->hset->get( key );
+
+  outlet_float(x->out0, output);
+}
+
+static void h_set_remove(t_h_set *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(!argc)
+    {
+      post("h_set, remove: no arguments"); 
+      return;
+    }  
+  
+  Element key(argc,argv);
+  x->hset->remove( key );
+}
+
+static void h_set_getsize(t_h_set *x)
+{
+  outlet_float(x->out1,x->hset->getSize());
+}
+
+static void h_set_help(t_h_set *x)
+{
+  x->hset->help();
+}
+
+static void h_set_set_namespace(t_h_set *x, t_symbol *s)
+{
+  x->hset->setNamespace(s->s_name);
+}
+
+static void h_set_get_namespace(t_h_set *x)
+{
+  post("h_set current namespace: %s",x->hset->getNamespace().c_str());
+}
+
+static void h_set_print(t_h_set *x)
+{
+  x->hset->printAll();
+}
+
+static void h_set_clear(t_h_set *x)
+{
+  x->hset->clearNamespace();
+}
+
+static void h_set_clear_all(t_h_set *x)
+{
+  x->hset->clearAll();
+}
+
+static void h_set_save(t_h_set *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hset->saveToFile(filename))
+    post("h_set: data of namespace %s written to file %s",
+	 x->hset->getNamespace().c_str(),s->s_name);
+  else
+    post("h_set: couldn't write to file %s",s->s_name);
+}
+
+static void h_set_read(t_h_set *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hset->readFromFile(filename))
+    post("h_set: couldn't read from file %s",s->s_name);
+}
+
+static void h_set_save_xml(t_h_set *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hset->saveToFileXML(filename))
+    post("h_set: data of namespace %s written to file %s",
+         x->hset->getNamespace().c_str(),s->s_name);
+  else
+    post("h_set: couldn't write to file %s",s->s_name);
+}
+
+static void h_set_read_xml(t_h_set *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hset->readFromFileXML(filename))
+    post("h_set: couldn't read from file %s",s->s_name);
+}
+
+static void *h_set_new(t_symbol *s, int argc, t_atom *argv) 
+{
+
+  t_h_set *x = (t_h_set *)pd_new(h_set_class);
+  
+  switch(argc)
+    {
+    default:
+      post("h_set warning: only one argument for namespace is possible!");
+    case 1:
+      x->hset = new HSet(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hset = new HSet();
+      break;
+    }
+
+  x->out0 = outlet_new(&x->x_obj, &s_float);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_set_free(t_h_set *x)
+{
+  delete x->hset;
+  return (void *)x;
+}
+
+void h_set_setup(void) 
+{
+  // the object class
+  h_set_class = class_new(gensym("h_set"), (t_newmethod)h_set_new,
+				(t_method)h_set_free, sizeof(t_h_set), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  class_addmethod(h_set_class, (t_method)h_set_add, 
+		  gensym("add"), A_GIMME , 0);
+  class_addmethod(h_set_class, (t_method)h_set_get, 
+		  gensym("get"), A_GIMME , 0);
+  class_addmethod(h_set_class, (t_method)h_set_remove, 
+		  gensym("remove"), A_GIMME , 0);
+  class_addmethod(h_set_class, (t_method)h_set_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_set_class, (t_method)h_set_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_set_class, (t_method)h_set_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_set_class, (t_method)h_set_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_set_class, (t_method)h_set_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_set_class, (t_method)h_set_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_set_class, (t_method)h_set_save, 
+		  gensym("save"), A_DEFSYMBOL , 0);
+  class_addmethod(h_set_class, (t_method)h_set_read, 
+		  gensym("read"), A_DEFSYMBOL , 0);
+  class_addmethod(h_set_class, (t_method)h_set_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_set_class, (t_method)h_set_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_set_class, (t_method)h_set_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_stack.cpp b/PDContainer/src/h_stack.cpp
new file mode 100755
index 0000000..e82933e
--- /dev/null
+++ b/PDContainer/src/h_stack.cpp
@@ -0,0 +1,165 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_stack.cpp
+
+
+#include "include/HStack.h"
+
+
+static t_class *h_stack_class;
+
+typedef struct _h_stack 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HStack *hstack;
+} t_h_stack;
+
+static void h_stack_push(t_h_stack *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hstack->push(key);
+    }
+  else
+    post("h_stack, push: no arguments");
+}
+
+static void h_stack_pop(t_h_stack *x)
+{
+  if(x->hstack->getSize()<=0)
+    {
+      post("h_stack, pop: size is 0 !");
+      return;
+    }
+
+  x->hstack->pop();
+}
+
+static void h_stack_top(t_h_stack *x)
+{
+  if(x->hstack->getSize() == 0)
+    {
+      outlet_bang(x->out2);
+      return;
+    }
+
+  Element output = x->hstack->top();
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+    
+  // no data
+  outlet_bang(x->out2);
+}
+
+static void h_stack_getsize(t_h_stack *x)
+{
+  outlet_float(x->out1,x->hstack->getSize());
+}
+
+static void h_stack_help(t_h_stack *x)
+{
+  x->hstack->help();
+}
+
+static void h_stack_set_namespace(t_h_stack *x, t_symbol *s)
+{
+  x->hstack->setNamespace(s->s_name);
+}
+
+static void h_stack_get_namespace(t_h_stack *x)
+{
+  post("h_stack current namespace: %s",x->hstack->getNamespace().c_str());
+}
+
+static void h_stack_clear(t_h_stack *x)
+{
+  x->hstack->clearNamespace();
+}
+
+static void h_stack_clear_all(t_h_stack *x)
+{
+  x->hstack->clearAll();
+}
+
+static void *h_stack_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_stack *x = (t_h_stack *)pd_new(h_stack_class);
+  
+  switch(argc)
+    {
+    default:
+      post("h_stack warning: only one argument for namespace is possible!");
+   case 1:
+      x->hstack = new HStack(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hstack = new HStack();
+      break;
+    }
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_stack_free(t_h_stack *x)
+{
+  delete x->hstack;
+  return (void *)x;
+}
+
+void h_stack_setup(void) 
+{
+  // the object class
+  h_stack_class = class_new(gensym("h_stack"), (t_newmethod)h_stack_new,
+				(t_method)h_stack_free, sizeof(t_h_stack), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  class_addmethod(h_stack_class, (t_method)h_stack_push, 
+		  gensym("push"), A_GIMME, 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_pop, 
+		  gensym("pop"), A_DEFFLOAT, 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_top, 
+		  gensym("top"), A_DEFFLOAT, 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_stack_class, (t_method)h_stack_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_stack_class, (t_method)h_stack_help, gensym("help"),A_DEFFLOAT, 0);
+}
diff --git a/PDContainer/src/h_vector.cpp b/PDContainer/src/h_vector.cpp
new file mode 100755
index 0000000..d3f76a3
--- /dev/null
+++ b/PDContainer/src/h_vector.cpp
@@ -0,0 +1,488 @@
+// *********************(c)*2004*********************>
+// -holzilib--holzilib--holzilib--holzilib--holzilib->
+// ++++PD-External++by+Georg+Holzmann++grh@gmx.at++++>
+//
+// PDContainer: 
+// this is a port of the containers from the C++ STL
+// (Standard Template Library)
+// for usage see the documentation and PD help files
+// for license see readme.txt
+//
+// h_vector.cpp
+
+
+#include "include/HVector.h"
+
+
+static t_class *h_vector_class;
+static t_class *proxy_class;
+
+typedef struct _h_vector 
+{
+  t_object  x_obj;
+  t_canvas *x_canvas;
+  t_outlet *out0, *out1, *out2;
+  HVector *hvector;
+  Element value;
+  bool event_set;
+} t_h_vector;
+
+typedef struct proxy
+{
+  t_object obj;
+  t_int index;  // number of proxy inlet(s)
+  t_h_vector *x;	// we'll put the other struct in here
+} t_proxy;
+
+static void h_vector_set(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_vector, set: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hvector->getSize() || index < 0 )
+    {
+      post("h_vector, set: invalid index!");
+      return;
+    }
+
+  if(!x->event_set)
+    {
+      post("h_vector, set: you must first set a value at right inlet!");
+      return;
+    }
+  
+  x->hvector->set( index , x->value); 
+  x->event_set = false;
+}
+
+static void h_vector_push_back(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  if(argc)
+    {
+      Element key(argc,argv);
+      x->hvector->pushBack(key);
+    }
+  else
+    post("h_vector, pushback: no arguments");
+}
+
+static void h_vector_insert(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_vector, insert: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hvector->getSize() || index < 0 )
+    {
+      post("h_vector, insert: invalid index!");
+      return;
+    }
+
+  if(!x->event_set)
+    {
+      post("h_vector, insert: you must first set a value at right inlet!");
+      return;
+    }
+  
+  x->hvector->insert( index , x->value); 
+  x->event_set = false;
+}
+
+static void h_vector_value(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
+{
+  t_h_vector *x = (t_h_vector *)(p->x);
+
+  // symbol without selector "symbol":
+  if(argc == 0)
+  {
+    t_atom tmp;
+    SETSYMBOL(&tmp, s);
+    x->value.setAtoms(1, &tmp);
+    x->event_set = true;
+    return;
+  }
+
+  // input is a list without selector "list":
+  if ( argc && (strcmp(s->s_name,"list")!=0) 
+       && (strcmp(s->s_name,"float")!=0) 
+       && (strcmp(s->s_name,"symbol")!=0)
+       && (strcmp(s->s_name,"pointer")!=0) )
+  {
+    t_atom *atoms = (t_atom*)getbytes( (argc+1)*sizeof(t_atom) );
+
+      // add the selector symbol to the list:
+    SETSYMBOL(atoms, s);
+
+    for(int i=0; i<argc; i++)
+    {
+      if(argv[i].a_type == A_FLOAT)
+	SETFLOAT(&atoms[i+1],argv[i].a_w.w_float);
+      if(argv[i].a_type == A_SYMBOL)
+	SETSYMBOL(&atoms[i+1],argv[i].a_w.w_symbol);
+      if(argv[i].a_type == A_POINTER)
+	SETPOINTER(&atoms[i+1],argv[i].a_w.w_gpointer);
+    }
+
+    x->value.setAtoms(argc+1, atoms);
+
+    x->event_set = true;
+    freebytes(atoms, (argc+1)*sizeof(t_atom));
+    return;
+  }
+
+  // "normal" input (list, float or symbol):
+  if (argc)
+  {
+    x->value.setAtoms(argc, argv);
+    x->event_set = true;
+    return;
+  }
+}
+
+static void h_vector_get(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_vector, get: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hvector->getSize() || index < 0 )
+    {
+      post("h_vector, get: invalid index!");
+      return;
+    }
+
+  Element output = x->hvector->get( index );
+ 
+  if(output.getLength() == 1) // symbol or float
+    {
+      if (output.getAtom()[0].a_type == A_FLOAT)
+	outlet_float(x->out0, output.getAtom()[0].a_w.w_float);
+      if (output.getAtom()[0].a_type == A_SYMBOL)
+	outlet_symbol(x->out0, output.getAtom()[0].a_w.w_symbol);
+      if (output.getAtom()[0].a_type == A_POINTER)
+	outlet_pointer(x->out0, output.getAtom()[0].a_w.w_gpointer);
+      return;
+    }
+  if(output.getLength() > 1) // list
+    {
+      outlet_list(x->out0,&s_list,output.getLength(),output.getAtom());
+      return;
+    }
+
+  // if there was no Element found, put out a bang at the right outlet
+  outlet_bang(x->out2);
+}
+
+static void h_vector_pop_back(t_h_vector *x)
+{
+  if(x->hvector->getSize()<=0)
+    {
+      post("h_vector, popback: size is already 0 !");
+      return;
+    }
+
+  x->hvector->popBack();
+}
+
+static void h_vector_remove(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int index;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    index = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_vector, remove: invalid index!");
+      return;
+    }
+
+  if ( index >= x->hvector->getSize() || index < 0 )
+    {
+      post("h_vector, remove: invalid index!");
+      return;
+    }
+  
+  x->hvector->remove(index); 
+  x->event_set = false;
+}
+
+static void h_vector_resize(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  int size;
+  if(argc && (argv[0].a_type == A_FLOAT))
+    size = static_cast<int>(argv[0].a_w.w_float);
+  else
+    {
+      post("h_vector, resize: invalid index!");
+      return;
+    }
+
+  if ( size < 0 )
+    {
+      post("h_vector, size: invalid size!");
+      return;
+    }
+
+  x->hvector->resize( size );
+}
+
+static void h_vector_getsize(t_h_vector *x)
+{
+  outlet_float(x->out1,x->hvector->getSize());
+}
+
+static void h_vector_help(t_h_vector *x)
+{
+  x->hvector->help();
+}
+
+static void h_vector_set_namespace(t_h_vector *x, t_symbol *s)
+{
+  x->hvector->setNamespace(s->s_name);
+}
+
+static void h_vector_get_namespace(t_h_vector *x)
+{
+  post("h_vector current namespace: %s",x->hvector->getNamespace().c_str());
+}
+
+static void h_vector_print(t_h_vector *x)
+{
+  x->hvector->printAllIndex();
+}
+
+static void h_vector_clear(t_h_vector *x)
+{
+  x->hvector->clearNamespace();
+}
+
+static void h_vector_clear_all(t_h_vector *x)
+{
+  x->hvector->clearAll();
+}
+
+static void h_vector_save(t_h_vector *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hvector->saveToFile(filename))
+    post("h_vector: data of namespace %s written to file %s",
+	 x->hvector->getNamespace().c_str(),s->s_name);
+  else
+    post("h_vector: couldn't write to file %s",s->s_name);
+}
+
+static void h_vector_read(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hvector->readFromFile(filename))
+    post("h_vector: couldn't read from file %s",s->s_name);
+}
+
+static void h_vector_read_at(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  string symbol;
+  int index=0;
+
+  switch(argc)
+    {
+    default:
+      post("h_vector read: only two argument are possible!");
+      break;
+    case 2:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = (int)argv[1].a_w.w_float;
+      break; 
+    case 1:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = 0;
+      break;
+    case 0:
+      post("h_vector read: no filename!");
+    }
+
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, (char*)symbol.c_str(), filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hvector->readFromFile2(filename,index))
+    post("h_vector: couldn't read from file %s",s->s_name);
+}
+
+static void h_vector_save_xml(t_h_vector *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(x->hvector->saveToFileXML(filename))
+    post("h_vector: data of namespace %s written to file %s",
+         x->hvector->getNamespace().c_str(),s->s_name);
+  else
+    post("h_vector: couldn't write to file %s",s->s_name);
+}
+
+static void h_vector_read_xml(t_h_vector *x, t_symbol *s)
+{
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, s->s_name, filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hvector->readFromFileXML(filename))
+    post("h_vector: couldn't read from file %s",s->s_name);
+}
+
+static void h_vector_read_at_xml(t_h_vector *x, t_symbol *s, int argc, t_atom *argv)
+{
+  string symbol;
+  int index=0;
+
+  switch(argc)
+    {
+    default:
+      post("h_vector read: only two argument are possible!");
+      break;
+    case 2:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = (int)argv[1].a_w.w_float;
+      break; 
+    case 1:
+      symbol = argv[0].a_w.w_symbol->s_name;
+      index = 0;
+      break;
+    case 0:
+      post("h_vector read: no filename!");
+    }
+
+  // make correct path
+  char filnam[MAXPDSTRING];
+  char filename[MAXPDSTRING];
+  canvas_makefilename(x->x_canvas, (char*)symbol.c_str(), filnam, MAXPDSTRING);
+  sys_bashfilename(filnam, filename);
+
+  if(!x->hvector->readFromFile2XML(filename,index))
+    post("h_vector: couldn't read from file %s",s->s_name);
+}
+
+static void *h_vector_new(t_symbol *s, int argc, t_atom *argv) 
+{
+  t_h_vector *x = (t_h_vector *)pd_new(h_vector_class);
+  t_proxy *inlet = (t_proxy *)pd_new(proxy_class); // for the proxy inlet
+
+  inlet->x = x;	// make x visible to the proxy inlets
+  
+  switch(argc)
+    {
+    default:
+      post("h_vector warning: only one argument for namespace is possible!");
+   case 1:
+      x->hvector = new HVector(atom_getsymbol(argv)->s_name);
+      break;
+    case 0:
+      x->hvector = new HVector();
+      break;
+    }
+
+  // we are going to create a proxy inlet no. 0
+  // it belongs to the object x but the destination is t_proxy
+  inlet->index = 0;
+  inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
+
+  x->out0 = outlet_new(&x->x_obj, 0);
+  x->out1 = outlet_new(&x->x_obj, &s_float);
+  x->out2 = outlet_new(&x->x_obj, &s_bang);
+  x->x_canvas = canvas_getcurrent();
+    
+  return (void *)x;
+}
+
+static void *h_vector_free(t_h_vector *x)
+{
+  delete x->hvector;
+  return (void *)x;
+}
+
+void h_vector_setup(void) 
+{
+  // the object class
+  h_vector_class = class_new(gensym("h_vector"), (t_newmethod)h_vector_new,
+				(t_method)h_vector_free, sizeof(t_h_vector), 
+				CLASS_DEFAULT, A_GIMME, 0);
+
+  // a class for the proxy-inlet
+  proxy_class = class_new(gensym("h_vector_proxy"), NULL, NULL, sizeof(t_proxy),
+			  CLASS_PD|CLASS_NOINLET, A_NULL);
+
+  class_addmethod(h_vector_class, (t_method)h_vector_set, 
+		  gensym("set"), A_GIMME, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_push_back, 
+		  gensym("pushback"), A_GIMME, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_insert, 
+		  gensym("insert"), A_GIMME, 0);
+  class_addanything(proxy_class, (t_method)h_vector_value); // the right inlet
+  class_addmethod(h_vector_class, (t_method)h_vector_get, 
+		  gensym("get"), A_GIMME, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_pop_back, 
+		  gensym("popback"), A_DEFFLOAT, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_remove, 
+		  gensym("remove"), A_GIMME, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_resize, 
+		  gensym("resize"), A_GIMME , 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_getsize, 
+		  gensym("getsize"), A_DEFFLOAT , 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_set_namespace, 
+		  gensym("namespace"), A_DEFSYMBOL , 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_get_namespace, 
+		  gensym("getnamespace"), A_DEFFLOAT, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_print,
+		  gensym("print"), A_DEFFLOAT, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_clear,  
+		  gensym("clear"), A_DEFFLOAT, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_clear_all,  
+		  gensym("clearall"), A_DEFFLOAT, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_save, 
+		  gensym("save"), A_DEFSYMBOL, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_read, 
+		  gensym("read"), A_DEFSYMBOL, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_read_at, 
+		  gensym("readat"), A_GIMME, 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_save_xml, 
+		  gensym("saveXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_read_xml, 
+		  gensym("readXML"), A_DEFSYMBOL , 0);
+  class_addmethod(h_vector_class, (t_method)h_vector_read_at_xml, 
+		  gensym("readatXML"), A_GIMME, 0);
+
+  // without an argument the following two methods wont work ??? why?? because of c++?
+  class_addmethod(h_vector_class, (t_method)h_vector_help, gensym("help"),A_DEFFLOAT, 0);
+}