[PD-cvs] externals/grh/PDContainer/src HDeque.cpp, NONE, 1.1 HList.cpp, NONE, 1.1 HMap.cpp, NONE, 1.1 HMultiMap.cpp, NONE, 1.1 HMultiSet.cpp, NONE, 1.1 HPrioQueue.cpp, NONE, 1.1 HQueue.cpp, NONE, 1.1 HSet.cpp, NONE, 1.1 HStack.cpp, NONE, 1.1 HVector.cpp, NONE, 1.1 PDContainer.cpp, NONE, 1.1 h_deque.cpp, NONE, 1.1 h_list.cpp, NONE, 1.1 h_map.cpp, NONE, 1.1 h_multimap.cpp, NONE, 1.1 h_multiset.cpp, NONE, 1.1 h_prioqueue.cpp, NONE, 1.1 h_queue.cpp, NONE, 1.1 h_set.cpp, NONE, 1.1 h_stack.cpp, NONE, 1.1 h_vector.cpp, NONE, 1.1
Georg Holzmann
grholzi at users.sourceforge.net
Fri Oct 21 13:56:34 CEST 2005
- Previous message: [PD-cvs] externals/grh/PDContainer CHANGELOG, NONE, 1.1 ClassHierarchy, NONE, 1.1 gpl.txt, NONE, 1.1 makefile, NONE, 1.1 makefile_darwin, NONE, 1.1 makefile_mingw, NONE, 1.1 makefile_msvc, NONE, 1.1 pdcontainer_multi.dtd, NONE, 1.1 pdcontainer_simple.dtd, NONE, 1.1 readme.txt, NONE, 1.1
- Next message: [PD-cvs] externals/grh/PDContainer/tinyxml tinystr.cpp, NONE, 1.1 tinystr.h, NONE, 1.1 tinyxml.cpp, NONE, 1.1 tinyxml.h, NONE, 1.1 tinyxmlerror.cpp, NONE, 1.1 tinyxmlparser.cpp, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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 at 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"
- Previous message: [PD-cvs] externals/grh/PDContainer CHANGELOG, NONE, 1.1 ClassHierarchy, NONE, 1.1 gpl.txt, NONE, 1.1 makefile, NONE, 1.1 makefile_darwin, NONE, 1.1 makefile_mingw, NONE, 1.1 makefile_msvc, NONE, 1.1 pdcontainer_multi.dtd, NONE, 1.1 pdcontainer_simple.dtd, NONE, 1.1 readme.txt, NONE, 1.1
- Next message: [PD-cvs] externals/grh/PDContainer/tinyxml tinystr.cpp, NONE, 1.1 tinystr.h, NONE, 1.1 tinyxml.cpp, NONE, 1.1 tinyxml.h, NONE, 1.1 tinyxmlerror.cpp, NONE, 1.1 tinyxmlparser.cpp, NONE, 1.1
- Messages sorted by:
[ date ]
[ thread ]
[ subject ]
[ author ]
More information about the Pd-cvs
mailing list