Am I storing correctly the object pointer here?….
note – tempbuf is a char array made from obj name/patcher name.
eg ::trk1::auxvol[1]

t_object *b;
b = (t_object *)gensym("#B")->s_thing;
t_hashtab *tab;
tab = (t_hashtab*)gensym("leighsobjecttable")->s_thing;
hashtab_store(tab, gensym(tempbuf), (t_object *)b);

Or is it my lookup that is incorrect?…..

t_object  *t;
t_hashtab *tab;
long n;
t_symbol *test; (is passed name of key - rg ::trk1::auxvol[1])
tab = (t_hashtab*)gensym("leighsobjecttable")->s_thing;
hashtab_lookup(tab, test, &t);
n = object_attr_getlong(t, gensym("param_value"));

I receive no error message, nor the long value I am trying to retrieve unfortunately. I have simply replaced a symbol->s-thing object pointer system with these hashtable parts, so I discount any other possible sources of the problem, eg incorrectly formatted char arrays/symbols.

When I print out a list of keys from my hashtable object it shows them all as being there, so I’m sure I’m missing something again, either in the storage or the lookup of the object pointer.
Many thanks should you get a moment to browse over this.

Cheers,
Leigh

t_hashtab* h = hashtab_new(2027); // prime numbers work well for size
t_symbol* s = gensym("foo");

s->s_thing = (t_object*)h;

Of course, blindly assigning to the s_thing as I did here is not safe as detailed in the article above.

Cheers!

I can see how to create an external that contains a hashtab (which I would place one instance of in my main patcher),
I’m a little perplexed as to how to bind the hashtab to a symbol, at least the syntax for doing such a thing. In xcode I tried binding to both the symbol and the s_thing field of a symbol but I get an ‘incompatible pointer type’ error. I guess I am overlooking something.

‘ I’m not really sure what you are doing ‘ – It’s rather complicated to explain, but it is a system for interacting with the Mackie series of control surfaces MCU/XT/C4. I intend to start documenting online soon. I’ll post you a link when this happens if you like.
Currently the development has is tailored to my setup, but once I am done I intend to make a more open version so people can easily incorporate the system into their existing setup, freebie externals of course!

Thanks again for your time, it’s much appreciated. If you are ever in Europe in need of a live sound engineer, then maybe I can repay you for your troubles!
Kind regards,
Leigh

Max’s symbol table is a hash table (http://en.wikipedia.org/wiki/Hash_table) with a reasonably large number of buckets. It is good to be cautious about bloating the symbol table though, because it affects the performance the entire application. So, 1000 symbols should not degrade Max’s performance too much. I would get start getting nervous if you were talking about 10000+ symbols.

Should you worry about other Max objects stepping on your pointers stored in a t_symbol::s_thing? Yes. Ideally all Max objects should be good citizens and not overwrite an s_thing if it has a value already. In reality, this is not enforced in the Max API. For example, can you count on all other third parties being careful about this when they might not have read about how to work with the s_thing?

I’m not really sure what you are doing, but there is another approach you might consider. Instead of binding an individual pointer to an individual s_thing, you could create a t_hashtab, and then bind that to one special symbol that is unlikely to be used, such as

 gensym("__++mySpecialSymbol##$$??").

Then store your pointers in this hashtab, with a the symbols are the keys. When any of your objects needs to get a pointer, it gets the hashtab pointer from your special symbol, and then gets the pointer by looking it up in that hashtab. This way you have symbols associated with pointers, you can access them from anywhere, and they are scoped to your situation so that you don’t conflict with the global environment.

Hope this helps!