Max 5 API Reference

jit.tree.c

/* 
    jit.tree.c

    Copyright 2001-2005 - Cycling '74
    Joshua Kit Clayton jkc@cycling74.com
        
*/

#include "jit.common.h"
#include "jit.linklist.h"
#include "jit.tree.h"

void *_jit_tree_class=NULL;
void *_jit_tree_node_class=NULL;

t_jit_err jit_tree_init(void);
void jit_tree_node_addinterface(t_class *c);


t_jit_err jit_tree_init()
{
    _jit_tree_class = jit_class_new("jit_tree",(method)jit_tree_new,(method)jit_tree_free,
        sizeof(t_jit_tree),A_CANT,0L); //A_CANT = untyped
        
    jit_tree_node_addinterface(_jit_tree_class);

    jit_class_register(_jit_tree_class);

    _jit_tree_node_class = jit_class_new("jit_tree_node",(method)jit_tree_node_new,(method)jit_tree_node_free,
        sizeof(t_jit_tree_node),A_CANT,0L); //A_CANT = untyped
        
    jit_tree_node_addinterface(_jit_tree_node_class);

    jit_class_register(_jit_tree_node_class);

    return JIT_ERR_NONE;
}

void jit_tree_node_addinterface(t_class *c)
{
    jit_class_addmethod(c, (method)jit_tree_node_thing,             "thing",                A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_getthing,          "getthing",             A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_getparent,         "getparent",            A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_getchild,          "getchild",             A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_getchildcount,     "getchildcount",        A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_getchildren,       "getchildren",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_insertchild,       "insertchild",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_appendchild,       "appendchild",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_deletechild,       "deletechild",          A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_replacechild,      "replacechild",         A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_replacechild,      "replacechuckchild",    A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_chuckchild,        "chuckchild",           A_CANT, 0L);

    jit_class_addmethod(c, (method)jit_tree_node_clear,             "clear",                A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_chuck,             "chuck",                A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_methodall,         "methodall",            A_CANT, 0L);
    jit_class_addmethod(c, (method)jit_tree_node_methodchild,       "methodchild",          A_CANT, 0L);
}


t_jit_tree *jit_tree_new(void)
{
    t_jit_tree *x;
    
    if (x = (t_jit_tree *)jit_object_alloc(_jit_tree_class)) {
        x->node.parent = NULL;
        x->node.thing = NULL;
        x->node.children = NULL;
        x->lock = NULL; //could use later
    }
    return x;
}

void jit_tree_free(t_jit_tree *x)
{   
    jit_tree_node_clear((t_jit_tree_node *)x);
}

t_jit_tree_node *jit_tree_node_new(t_jit_object *thing)
{
    t_jit_tree_node *x;
    
    if (x = (t_jit_tree_node *)jit_object_alloc(_jit_tree_node_class)) {
        x->parent = NULL;
        x->thing = thing;
        x->children = NULL;
    }
    return x;
}

void jit_tree_node_free(t_jit_tree_node *x)
{   
    jit_tree_node_clear((t_jit_tree_node *)x);
    x->parent = NULL;
}

void jit_tree_node_clear(t_jit_tree_node *x)
{   
    if (x->children)
        jit_object_free(x->children);
    x->children = NULL;
    if (x->thing) {
        jit_object_free((t_jit_object *)x->thing);
        x->thing = NULL;
    }
}

void jit_tree_node_chuck(t_jit_tree_node *x)
{   
    if (x->children) {
        jit_linklist_methodall(x->children,_jit_sym_chuck);
        jit_linklist_chuck(x->children);
        x->children = NULL;
    }
    x->thing = NULL;
    x->parent = NULL;
    jit_object_free((t_jit_object *)x);
}

void jit_tree_node_methodall(t_jit_tree_node *x, t_symbol *s, ...)
{   
    if (x->children) {
        jit_linklist_methodall(x->children,_jit_sym_methodall,s,*((t_stack_splat *)(((char *)(&s))+4)));
        if (x->thing)
            jit_object_method(x->thing,s,*((t_stack_splat *)(((char *)(&s))+4)));
    }
}

void jit_tree_node_methodchild(t_jit_tree_node *x, long i, t_symbol *s, ...)
{   
    if (x->children) {
        jit_linklist_methodindex(x->children,i,s,*((t_stack_splat *)(((char *)(&s))+4)));
    }
}

void jit_tree_node_thing(t_jit_tree_node *x, t_jit_object *thing)
{   
    x->thing = thing;
}

t_jit_object *jit_tree_node_getthing(t_jit_tree_node *x)
{   
    return x->thing;
}

t_jit_tree_node *jit_tree_node_getparent(t_jit_tree_node *x)
{   
    return (t_jit_tree_node *)x->parent;
}

t_jit_tree_node *jit_tree_node_getchild(t_jit_tree_node *x, long index)
{   
    if (x->children)    
        return (t_jit_tree_node *)jit_linklist_getindex(x->children,index);
    else 
        return NULL;
}

long jit_tree_node_getchildcount(t_jit_tree_node *x)
{   
    if (x->children)    
        return jit_linklist_getsize(x->children);
    else 
        return 0;
}

t_jit_linklist *jit_tree_node_getchildren(t_jit_tree_node *x)
{   
    return x->children;
}

void jit_tree_node_insertchild(t_jit_tree_node *x, t_jit_tree_node *o, long index)
{   
    if (!x->children)
        x->children = (t_jit_linklist *) jit_linklist_new();
    if (x->children&&o) {   
        o->parent = x;
        jit_linklist_insertindex(x->children,o,index);
    }
}

void jit_tree_node_appendchild(t_jit_tree_node *x, t_jit_tree_node *o)
{   
    if (!x->children)
        x->children = (t_jit_linklist *) jit_linklist_new();
    if (x->children&&o) {   
        o->parent = x;
        jit_linklist_append(x->children,o);
    }
}

void jit_tree_node_replacechild(t_jit_tree_node *x, t_jit_tree_node *o, long index)
{   
    if (!x->children)
        x->children = (t_jit_linklist *) jit_linklist_new();
    if (x->children&&o) {   
        o->parent = x;
        jit_tree_node_deletechild(x,index);
        jit_linklist_insertindex(x->children,o,index);
    }
}

void jit_tree_node_replacechuckchild(t_jit_tree_node *x, t_jit_tree_node *o, long index)
{   
    if (x->children) {  
        jit_tree_node_chuckchild(x,index);
        jit_linklist_insertindex(x->children,o,index);
    }
}

void jit_tree_node_replaceremovechild(t_jit_tree_node *x, t_jit_tree_node *o, long index)
{   
    if (x->children&&o) {   
        o->parent = x;
        jit_tree_node_removechild(x,index);
        jit_linklist_insertindex(x->children,o,index);
    }
}

void jit_tree_node_deletechild(t_jit_tree_node *x, long index)
{   
    t_jit_tree_node *child;
    if (x->children) {  
        if (child=(t_jit_tree_node *)jit_linklist_getindex(x->children,index))
            child->parent = NULL;
        jit_linklist_deleteindex(x->children,index);
    }
}

void jit_tree_node_chuckchild(t_jit_tree_node *x, long index)
{   
    t_jit_tree_node *child;
    if (x->children) {  
        if (child=(t_jit_tree_node *)jit_linklist_getindex(x->children,index))
            child->parent = NULL;
        jit_linklist_methodindex(x->children,index,_jit_sym_chuck);
        jit_linklist_deleteindex(x->children,index);
    }
}

void jit_tree_node_removechild(t_jit_tree_node *x, long index)
{   
    t_jit_tree_node *child;
    if (x->children) {  
        if (child=(t_jit_tree_node *)jit_linklist_getindex(x->children,index))
            child->parent = NULL;
        jit_linklist_chuckindex(x->children,index);
    }
}

Copyright © 2008, Cycling '74