21 Oct 2005


      Update of /cvsroot/pure-data/externals/grh/PDContainer/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15862/src
Added Files:
    HDeque.cpp HList.cpp HMap.cpp HMultiMap.cpp HMultiSet.cpp 
    HPrioQueue.cpp HQueue.cpp HSet.cpp HStack.cpp HVector.cpp 
    PDContainer.cpp h_deque.cpp h_list.cpp h_map.cpp 
    h_multimap.cpp h_multiset.cpp h_prioqueue.cpp h_queue.cpp 
    h_set.cpp h_stack.cpp h_vector.cpp 
Log Message:
only moving to a new directory
--- NEW FILE: h_multiset.cpp ---
// *********************(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);
}
--- NEW FILE: h_multimap.cpp ---
// *********************(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);
}
--- NEW FILE: HMultiMap.cpp ---
// *********************(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 !";
}
--- NEW FILE: HMultiSet.cpp ---
// *********************(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"
--- NEW FILE: HList.cpp ---
// *********************(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;
}
--- NEW FILE: h_stack.cpp ---
// *********************(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);
}
--- NEW FILE: h_prioqueue.cpp ---
// *********************(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);
}
--- NEW FILE: HQueue.cpp ---
// *********************(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"
--- NEW FILE: h_deque.cpp ---
// *********************(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);
}
--- NEW FILE: HSet.cpp ---
// *********************(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"
--- NEW FILE: h_queue.cpp ---
// *********************(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);
}
--- NEW FILE: h_vector.cpp ---
// *********************(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);
}
--- NEW FILE: h_list.cpp ---
// *********************(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);
}
--- NEW FILE: HMap.cpp ---
// *********************(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"
--- NEW FILE: HVector.cpp ---
// *********************(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"
--- NEW FILE: h_map.cpp ---
// *********************(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);
}
--- NEW FILE: HPrioQueue.cpp ---
// *********************(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"
--- NEW FILE: PDContainer.cpp ---
// *********************(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);
}
--- NEW FILE: HStack.cpp ---
// *********************(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"
--- NEW FILE: h_set.cpp ---
// *********************(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);
}
--- NEW FILE: HDeque.cpp ---
// *********************(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"

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003