Jamoma API  0.6.0.a19
Max/source/j.namespace/j.namespace.cpp
Go to the documentation of this file.
1 /** @file
2  *
3  * @ingroup implementationMaxExternals
4  *
5  * @brief j.namespace - deal with the Jamoma Namespace
6  *
7  * @details
8  *
9  * @authors Théo de la Hogue, Trond Lossius
10  *
11  * @copyright Copyright © 2010 Théo de la Hogue @n
12  * This code is licensed under the terms of the "New BSD License" @n
13  * http://creativecommons.org/licenses/BSD/
14  */
15 
16 
18 
19 #define data_out 0
20 #define size_out 1
21 #define dump_out 2
22 
23 // Definitions
24 void WrapTTExplorerClass(WrappedClassPtr c);
25 void WrappedExplorerClass_new(TTPtr self, long argc, t_atom *argv);
26 void WrappedExplorerClass_free(TTPtr self);
27 
28 void nmspc_assist(TTPtr self, void *b, long m, long a, char *s);
29 
30 void nmspc_return_value(TTPtr self, t_symbol *msg, long argc, t_atom *argv);
31 
32 void nmspc_return_selection(TTPtr self, t_symbol *msg, long argc, t_atom *argv);
33 
34 void nmspc_bang(TTPtr self);
35 void nmspc_symbol(TTPtr self, t_symbol *msg, long argc, t_atom *argv);
36 
37 void nmspc_subscribe(TTPtr self);
38 
39 void nmspc_return_model_address(TTPtr self, t_symbol *msg, long argc, t_atom *argv);
40 
41 t_max_err nmspc_get_format(TTPtr self, TTPtr attr, long *ac, t_atom **av);
42 t_max_err nmspc_set_format(TTPtr self, TTPtr attr, long ac, t_atom *av);
43 
44 t_max_err nmspc_get_relative(TTPtr self, TTPtr attr, long *ac, t_atom **av);
45 t_max_err nmspc_set_relative(TTPtr self, TTPtr attr, long ac, const t_atom *av);
46 
47 /*
48 void nmspc_add_max_namespace(TTPtr self);
49 long nmspc_myobject_iterator(TTPtr self, (t_object*) b);
50 */
51 
52 //t_symbol *nmspc_filter_underscore_instance(t_symbol *a);
53 
54 
55 int C74_EXPORT main(void)
56 {
57  ModularSpec *spec = new ModularSpec;
58  spec->_wrap = &WrapTTExplorerClass;
59  spec->_new = &WrappedExplorerClass_new;
60  spec->_free = &WrappedExplorerClass_free;
61  spec->_any = NULL;
62 
63  return wrapTTModularClassAsMaxClass(kTTSym_Explorer, "j.namespace", NULL, spec);
64 }
65 
66 void WrapTTExplorerClass(WrappedClassPtr c)
67 {
68  // add methods
69  class_addmethod(c->maxClass, (method)nmspc_assist, "assist", A_CANT, 0);
70 
71  class_addmethod(c->maxClass, (method)nmspc_return_value, "return_value", A_CANT, 0);
72 
73  class_addmethod(c->maxClass, (method)nmspc_return_model_address,"return_model_address", A_CANT, 0);
74 
75  class_addmethod(c->maxClass, (method)nmspc_return_selection, "return_selection", A_CANT, 0);
76 
77  class_addmethod(c->maxClass, (method)nmspc_bang, "bang", 0);
78 
79  class_addmethod(c->maxClass, (method)nmspc_symbol, "anything", A_GIMME, 0);
80 
81  class_addmethod(c->maxClass, (method)nmspc_bang, "explore", 0); // overwrite explore message to use the bang method
82 
83  //class_addmethod(c->maxClass, (method)nmspc_add_max_namespace, "add_max_namespace", 0);
84 
85  CLASS_ATTR_ENUM(c->maxClass, "output", 0, "descendants children brothers attributes");
86 
87  CLASS_ATTR_SYM(c->maxClass, "format", 0, WrappedModularInstance, msg); // use msg member to store format
88  CLASS_ATTR_ACCESSORS(c->maxClass, "format", nmspc_get_format, nmspc_set_format);
89  CLASS_ATTR_ENUM(c->maxClass, "format", 0, "none umenu umenu_prefix jit.cellblock coll");
90 
91  CLASS_ATTR_LONG(c->maxClass, "relative", 0, WrappedModularInstance, index); // use index member to store relative
92  CLASS_ATTR_ACCESSORS(c->maxClass, "relative", nmspc_get_relative, nmspc_set_relative);
93  CLASS_ATTR_STYLE(c->maxClass, "relative", 0, "onoff");
94 }
95 
96 void WrappedExplorerClass_new(TTPtr self, long argc, t_atom *argv)
97 {
99  long attrstart = attr_args_offset(argc, argv); // support normal arguments
100  t_symbol* name;
101  TTAddress address;
102  TTValue v, args;
103 
104  // create the explorer
105  jamoma_explorer_create((t_object*)x, x->wrappedObject);
106 
107  // read first argument to know if the explorer handles a namespace
108  if (attrstart && argv) {
109 
110  if (atom_gettype(argv) == A_SYM) {
111 
112  name = atom_getsym(argv);
113  x->wrappedObject.set(kTTSym_namespace, TTSymbol(name->s_name));
114  }
115  else
116  object_error((t_object*)x, "argument not expected");
117  }
118 
119  // Make two outlets
120  x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 2);
121  x->outlets[size_out] = outlet_new(x, NULL);
122  x->outlets[data_out] = outlet_new(x, NULL);
123 
124  x->msg = _sym_none;
125 
126  // handle attribute args
127  attr_args_process(x, argc, argv);
128 }
129 
130 void WrappedExplorerClass_free(TTPtr self)
131 {
133  x->wrappedObject.set(kTTSym_namespace, kTTSymEmpty);
134 }
135 
136 void nmspc_assist(TTPtr self, void *b, long msg, long arg, char *dst)
137 {
138  if (msg==1) // Inlet
139  strcpy(dst, "input");
140  else { // Outlets
141  switch(arg) {
142  case data_out:
143  strcpy(dst, "result of exploration");
144  break;
145  case size_out:
146  strcpy(dst, "size of the result (after the result)");
147  break;
148  case dump_out:
149  strcpy(dst, "dumpout");
150  break;
151  }
152  }
153 }
154 
155 void nmspc_subscribe(TTPtr self)
156 {
158  TTValue v;
159  TTAddress contextAddress = kTTAdrsEmpty;
160  TTAddress absoluteAddress, returnedAddress;
161  TTNodePtr returnedNode;
162  TTNodePtr returnedContextNode;
163  TTObject anObject, empty;
164 
166 
167  if (!jamoma_subscriber_create((t_object*)x, empty, kTTAdrsEmpty, x->subscriberObject, returnedAddress, &returnedNode, &returnedContextNode)) {
168 
169  // get the context address to make
170  // a receiver on the contextAddress/model:address attribute
171  x->subscriberObject.get("contextAddress", v);
172  contextAddress = v[0];
173  }
174 
175  // bind on the model:address attribute
176  if (contextAddress != kTTAdrsEmpty) {
177 
178  absoluteAddress = contextAddress.appendAddress(x->address);
179  x->wrappedObject.set(kTTSym_address, x->address);
180 
181  makeInternals_receiver(x, contextAddress, TTSymbol("/model:address"), gensym("return_model_address"), anObject, YES); // YES : we want to deferlow this method
182  }
183 
184  // while the context node is not registered : try to binds again :(
185  // (to -- this is not a good way todo. For binding we should make a subscription
186  // to a notification mechanism and each time an TTObjet subscribes to the namespace
187  // using jamoma_subscriber_create we notify all the externals which have used
188  // jamoma_subscriber_create with NULL object to bind)
189  else {
190 
191  // release the subscriber
192  x->subscriberObject = TTObject();
193 
194  // The following must be deferred because we have to interrogate our box,
195  // and our box is not yet valid until we have finished instantiating the object.
196  // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
197  defer_low((t_object*)x, (method)nmspc_subscribe, NULL, 0, 0);
198  }
199 }
200 
201 void nmspc_return_model_address(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
202 {
204  TTAddress absoluteAddress;
205 
206  // the wrapped object is maybe destroyed
207  if (!x->wrappedObject.valid())
208  return;
209 
210  if (argc && argv) {
211 
212  // set address attribute of the wrapped Receiver object
213  absoluteAddress = TTAddress(atom_getsym(argv)->s_name).appendAddress(x->address);
214  x->wrappedObject.set(kTTSym_address, absoluteAddress);
215  x->wrappedObject.send("Explore");
216  }
217 }
218 
219 void nmspc_return_value(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
220 {
222  TTValue v;
223  TTSymbol output;
224  TTAddress address;
225  t_symbol *s;
226  TTInt32 i;
227  t_atom a[1], c[2], j[3];
228 
229  // the wrapped object is maybe destroyed
230  if (!x->wrappedObject.valid())
231  return;
232 
233  // Ask Explorer object
234  x->wrappedObject.get("output", v);
235  output = v[0];
236 
237  x->wrappedObject.get(kTTSym_address, v);
238  address = v[0];
239 
240  // UMENU OR UMENU_PREFIX FORMAT
241  if (x->msg == gensym("umenu") || x->msg == gensym("umenu_prefix")) {
242 
243  // clear menu
244  outlet_anything(x->outlets[data_out], _sym_clear, 0, NULL);
245 
246  // prepare umenu prefix to be concatenated
247  if (x->msg == gensym("umenu_prefix")) {
248 
249  atom_setlong(a, 0);
250  outlet_anything(x->outlets[data_out], gensym("prefix_mode"), 1, a);
251 
252  // prepare umenu prefix
253  if (address.getName() == S_SEPARATOR) {
254 
255  TTString prefix = address.c_str();
256 
257  if (output == kTTSym_attributes)
258  prefix += ":";
259 
260  atom_setsym(a, gensym((char*)prefix.data()));
261  }
262  else {
263  TTString prefix = address.c_str();
264 
265  if (output == kTTSym_children)
266  prefix += "/";
267  else if (output == kTTSym_brothers)
268  prefix += ".";
269  else if (output == kTTSym_attributes)
270  prefix += ":";
271  else
272  prefix += "/";
273 
274  atom_setsym(a, gensym((char*)prefix.data()));
275  }
276 
277  outlet_anything(x->outlets[data_out], gensym("prefix"), 1, a);
278  }
279 
280  // fill umenu
281  // output argv
282  for (i = 0; i < argc; i++) {
283  s = atom_getsym(argv+i);
284 
285  if (output == kTTSym_descendants && address.getName() == S_SEPARATOR)
286  if (s->s_name[0] == C_SEPARATOR)
287  s = gensym(s->s_name+1); // remove the / in this case
288 
289  if (output == kTTSym_attributes)
290  s = jamoma_TTName_To_MaxName(TTSymbol(s->s_name));
291 
292  if (output == kTTSym_brothers && s == _sym_bang)
293  s = gensym("0");
294 
295  if (s) {
296  atom_setsym(a, s);
297  outlet_anything(x->outlets[data_out], _sym_append, 1, a);
298  }
299  }
300  }
301 
302  // JIT CELLBLOCK FORMAT
303  else if (x->msg == gensym("jit.cellblock")) {
304 
305  // clear jit.cellblock
306  atom_setsym(a, gensym("all"));
307  outlet_anything(x->outlets[data_out], _sym_clear, 1, a);
308 
309  // prepare jit.cellblock structure
310  atom_setlong(a, argc);
311  outlet_anything(x->outlets[data_out], gensym("rows"), 1, a);
312 
313  // fill jit.cellblock
314  // output argv
315  for (i = 0; i < argc; i++) {
316  s = atom_getsym(argv+i);
317 
318  if (output == kTTSym_attributes)
319  s = jamoma_TTName_To_MaxName(TTSymbol(s->s_name));
320 
321  if (output == kTTSym_brothers && s == _sym_bang)
322  s = gensym("0");
323 
324  if (s) {
325  atom_setlong(j, 0);
326  atom_setlong(j+1, i);
327  atom_setsym(j+2, s);
328  outlet_anything(x->outlets[data_out], _sym_set, 3, j);
329  }
330  }
331  }
332 
333  // COLL FORMAT
334  else if (x->msg == gensym("coll")) {
335 
336  // clear coll
337  outlet_anything(x->outlets[data_out], _sym_clear, 0, NULL);
338 
339  // fill coll
340  // output argv
341  for (i=0; i<argc; i++) {
342  s = atom_getsym(argv+i);
343 
344  if (output == kTTSym_attributes)
345  s = jamoma_TTName_To_MaxName(TTSymbol(s->s_name));
346 
347  if (output == kTTSym_brothers && s == _sym_bang)
348  s = gensym("0");
349 
350  if (s) {
351  atom_setsym(c, s);
352  atom_setlong(c+1, 0); // any data to avoid storage error
353  outlet_anything(x->outlets[data_out], _sym_store, 2, c);
354  }
355  }
356  }
357 
358  // NO FORMAT
359  else if (x->msg == gensym("none") || x->msg == _sym_nothing) {
360  if (argc)
361  outlet_atoms(x->outlets[data_out], argc, argv);
362  else if (msg != _sym_nothing)
363  outlet_anything(x->outlets[data_out], msg, argc, argv);
364  }
365 
366  // output the size of the result after the result
367  // to perform auto selection in case the result contains only 1 item
368  atom_setlong(a, argc);
369  outlet_anything(x->outlets[size_out], _sym_int, 1, a);
370 }
371 
372 void nmspc_return_selection(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
373 {
375  TTValue v;
376  TTSymbol output;
377  TTUInt32 i, state;
378  t_atom u[2], j[6];
379 
380  // the wrapped object is maybe destroyed
381  if (!x->wrappedObject.valid())
382  return;
383 
384  // Ask Explorer object
385  x->wrappedObject.get("output", v);
386  output = v[0];
387 
388  // UMENU OR UMENU_PREFIX FORMAT
389  if (x->msg == gensym("umenu") || x->msg == gensym("umenu_prefix")) {
390 
391  // clear check item
392  outlet_anything(x->outlets[data_out], gensym("clearchecks"), 0, NULL);
393 
394  // update check item
395  for (i = 0; i < (TTUInt32) argc; i++) {
396  state = atom_getlong(argv+i);
397  atom_setlong(u, i);
398  atom_setlong(u+1, state);
399  outlet_anything(x->outlets[data_out], gensym("checkitem"), 2, u);
400  }
401  }
402 
403  // JIT CELLBLOCK FORMAT
404  else if (x->msg == gensym("jit.cellblock")) {
405 
406  // update background color
407  for (i = 0; i < (TTUInt32) argc; i++) {
408 
409  atom_setlong(j, 0);
410  atom_setlong(j+1, i);
411  atom_setsym(j+2, gensym("brgb"));
412 
413  state = atom_getlong(argv+i);
414 
415  if (state) {
416  atom_setlong(j+3, 158);
417  atom_setlong(j+4, 0);
418  atom_setlong(j+5, 92);
419  }
420  else {
421  atom_setlong(j+3, 0);
422  atom_setlong(j+4, 0);
423  atom_setlong(j+5, 0);
424  }
425 
426  outlet_anything(x->outlets[data_out], gensym("cell"), 6, j);
427  }
428  }
429 
430  // COLL FORMAT
431  else if (x->msg == gensym("coll")) {
432  ;
433  }
434 
435  // NO FORMAT
436  else if (x->msg == gensym("none") || x->msg == _sym_nothing)
437  outlet_anything(x->outlets[data_out], gensym("selection"), argc, argv);
438 }
439 
440 void nmspc_bang(TTPtr self)
441 {
443 
444  // UMENU OR UMENU_PREFIX FORMAT : clear umenu
445  if (x->msg == gensym("umenu") || x->msg == gensym("umenu_prefix"))
446  outlet_anything(x->outlets[data_out], _sym_clear, 0, NULL);
447 
448  x->wrappedObject.send("Explore");
449 }
450 
451 void nmspc_symbol(TTPtr self, t_symbol *msg, long argc, t_atom *argv)
452 {
454  TTValue v;
455  TTAddress adrs, absoluteAddress;
456 
457  // for absolute address
458  adrs = TTAddress(msg->s_name);
459  if (adrs.getType() == kAddressAbsolute) {
460  v.append(adrs);
461  }
462  else {
463 
464  // if the relative attribute is on
465  if (x->index) {
466  absoluteAddress = x->patcherAddress.appendAddress(adrs);
467  v.append(absoluteAddress);
468  }
469  else {
470  object_error((t_object*)x, "set relative attribute on before to send relative address");
471  return;
472  }
473  }
474 
475  x->wrappedObject.set(kTTSym_address, v);
476 
477  // UMENU OR UMENU_PREFIX FORMAT : clear umenu
478  if (x->msg == gensym("umenu") || x->msg == gensym("umenu_prefix"))
479  outlet_anything(x->outlets[data_out], _sym_clear, 0, NULL);
480 
481  x->wrappedObject.send("Explore");
482 }
483 
484 /*
485 void nmspc_add_max_namespace(t_nmspc *x)
486 {
487  t_object *patcher;
488  t_max_err err;
489  long result = 0;
490 
491  err = object_obex_lookup(x, gensym("#P"), &patcher);
492 
493  object_method(patcher, gensym("iterate"), nmspc_myobject_iterator, (void *)x, PI_WANTBOX | PI_DEEP, &result);
494 }
495 
496 long nmspc_myobject_iterator(t_nmspc *x, t_object *b)
497 {
498  TTNodePtr newTTNode;
499  bool newInstanceCreated;
500  char temp[256];
501  t_symbol *varname = object_attr_getsym(b, gensym("varname"));
502  uint i;
503 
504  // Make sure we are dealing with valid OSC input by looking for a leading slash
505  if (varname) {
506  if (varname->s_name[0] == C_SEPARATOR) {
507  newInstanceCreated = false;
508 
509  // put all scripting name in a /max node
510  snprintf(temp,256,"/max%s", varname->s_name);
511 
512  // search for [ and ] cause this is how max declare instance.
513  for (i=0; i<strlen(temp); i++) {
514  if (temp[i] == '[')
515  temp[i] = '.';
516  else if (temp[i] == ']')
517  temp[i] = 0;
518  }
519 
520  jamoma_directory_register(gensym(temp), gensym("maxobject"), (t_object *)b, &newTTNode, &newInstanceCreated);
521 
522  // add varname and maxclass as properties of the node
523  //TODO : max_node_attribute_add(newTTNode,gensym("varname"), b);
524  //TODO : max_node_attribute_add(newTTNode,gensym("maxclass"), b);
525 
526  //if (newInstanceCreated)
527  // object_warn((t_object *)x,"%s : this scripting name is already registered in the tree", varname->s_name);
528  }
529  }
530 
531  return 0;
532 }
533  */
534 
535 t_max_err nmspc_get_format(TTPtr self, TTPtr attr, long *ac, t_atom **av)
536 {
538 
539  if ((*ac)&&(*av)) {
540  //memory passed in, use it
541  } else {
542  //otherwise allocate memory
543  *ac = 1;
544  if (!(*av = (t_atom*)getbytes(sizeof(t_atom)*(*ac)))) {
545  *ac = 0;
546  return MAX_ERR_OUT_OF_MEM;
547  }
548  }
549 
550  atom_setsym(*av, x->msg);
551 
552  return MAX_ERR_NONE;
553 }
554 
555 t_max_err nmspc_set_format(TTPtr self, TTPtr attr, long ac, t_atom *av)
556 {
558 
559  if (ac&&av) {
560  x->msg = atom_getsym(av);
561  } else {
562  // no args, set to none
563  x->msg = _sym_none;
564  }
565  return MAX_ERR_NONE;
566 }
567 
568 t_max_err nmspc_get_relative(TTPtr self, TTPtr attr, long *ac, t_atom **av)
569 {
571 
572  if ((*ac)&&(*av)) {
573  //memory passed in, use it
574  } else {
575  //otherwise allocate memory
576  *ac = 1;
577  if (!(*av = (t_atom*)getbytes(sizeof(t_atom)*(*ac)))) {
578  *ac = 0;
579  return MAX_ERR_OUT_OF_MEM;
580  }
581  }
582 
583  atom_setlong(*av, x->index);
584 
585  return MAX_ERR_NONE;
586 }
587 
588 t_max_err nmspc_set_relative(TTPtr self, TTPtr attr, long ac, const t_atom *av)
589 {
591 
592  if (ac&&av) {
593  x->index = atom_getlong(av);
594 
595  if (x->index) {
596  // The following must be deferred because we have to interrogate our box,
597  // and our box is not yet valid until we have finished instantiating the object.
598  // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6)
599  defer_low((t_object*)x, (method)nmspc_subscribe, NULL, 0, 0);
600  }
601 
602  } else {
603  // no args
604  x->index = 0;
605  }
606  return MAX_ERR_NONE;
607 }
TTErr JAMOMA_EXPORT jamoma_patcher_get_info(t_object *obj, t_object **returnedPatcher, TTSymbol &returnedContext, TTSymbol &returnedClass, TTSymbol &returnedName)
Get all context info from an object (his patcher and the context, the class and the name of his patch...
TTAddress appendAddress(const TTAddress &toAppend)
Return a new TTAddress with the appended part.
Definition: TTAddress.h:167
TTObject subscriberObject
The instance of a TTSubscriber object used to register the wrapped object in the tree structure...
TTErr send(const TTSymbol aName)
Send a message to this object with no arguments.
Definition: TTObject.cpp:135
TTHandle outlets
an array of outlet
TTErr wrapTTModularClassAsMaxClass(TTSymbol &ttblueClassName, const char *maxClassName, WrappedClassPtr *c, ModularSpec *specificities)
Wrap a Jamoma class as a Max class.
TTErr JAMOMA_EXPORT jamoma_explorer_create(t_object *x, TTObject &returnedExplorer)
Create a TTExplorer object.
We build a directory of TTNodes, and you can request a pointer for any TTNode, or add an observer to ...
Definition: TTNode.h:59
TTAddress address
sometime external needs to store an address (e.g. send, receive, view, ...)
TTSymbol patcherClass
the patcher class in which the external is
The TTAddress class is used to represent a string and efficiently pass and compare that string...
Definition: TTAddress.h:29
Create and use Jamoma object instances.
Definition: TTObject.h:29
t_object * patcherPtr
the patcher in which the external is (ignoring subpatcher)
int C74_EXPORT main(void)
Set up this class as a Max external the first time an object of this kind is instantiated.
void append(const T &anElementValueToAppend)
Insert a single TTElement at the end.
Definition: TTValue.h:243
void * TTPtr
A generic pointer.
Definition: TTBase.h:248
TTErr get(const TTSymbol aName, T &aReturnedValue) const
Get an attribute value for an object.
TTErr set(const TTSymbol aName, T aValue)
Set an attribute value for an object.
The TTSymbol class is used to represent a string and efficiently pass and compare that string...
Definition: TTSymbol.h:26
t_symbol JAMOMA_EXPORT * jamoma_TTName_To_MaxName(TTSymbol TTName)
Convert a TTSymbol "MyObjectMessage" into a t_symbol *"my/object/message" or return NULL if the TTSym...
TTAddress patcherAddress
the patcher address in which the external is
TTObject wrappedObject
The instance of the Jamoma object we are wrapping.
this flag means that an address have a leading slash
Definition: TTAddressBase.h:65
const char * c_str() const
Return a pointer to the internal string as a C-string.
Definition: TTSymbol.h:77
std::int32_t TTInt32
32 bit signed integer
Definition: TTBase.h:177
Data Structure for this object.
TTAddressType getType()
Get the type.
Definition: TTAddress.h:136
Wraps Jamoma Core classes as objects for Max/MSP.
std::uint32_t TTUInt32
32 bit unsigned integer
Definition: TTBase.h:178
TTSymbol patcherContext
the patcher context in which the external is (model, view)
TTSymbol patcherName
the patcher name in which the external is
TTErr JAMOMA_EXPORT jamoma_subscriber_create(t_object *x, TTObject &anObject, TTAddress relativeAddress, TTObject &returnedSubscriber, TTSymbol &returnedAddress, TTNodePtr *returnedNode, TTNodePtr *returnedContextNode)
Create a #TTSubscriber object and register a TTObject into the tree or, if aTTObject is NULL...
The TTString class is used to represent a string.
Definition: TTString.h:34
long index
index of the inlet used
TTBoolean valid() const
Determine if the object contained by this TTObject is truly ready for use.
Definition: TTObject.cpp:179
TTSymbol & getName()
Get the name part.
Definition: TTAddress.h:118
WrappedModularInstance * WrappedModularInstancePtr
Pointer to a wrapped instance of our object.
[doxygenAppendixC_copyExample]
Definition: TTValue.h:34