core/object.c

Go to the documentation of this file.

#include <float.h>
#include <math.h>

#ifdef WIN32
#define isnan _isnan  /* map isnan to appropriate function under Windows */
#endif

#include "object.h"
#include "convert.h"
#include "output.h"
#include "globals.h"

/* object list */
static OBJECTNUM next_object_id = 0;
static OBJECTNUM deleted_object_count = 0;
static OBJECT *first_object = NULL;
static OBJECT *last_object = NULL;
static OBJECTNUM object_array_size = 0;
static OBJECT **object_array = NULL;
#define QNAN sqrt(-1) 
/* {name, val, next} */
KEYWORD oflags[] = {
    /* "name", value, next */
    {"NONE",OF_NONE,oflags+1},
    {"HASPLC",OF_HASPLC,oflags+2},
    {"LOCKED",OF_LOCKED,oflags+3},
    {"RERANKED",OF_RERANK,oflags+4},
    {"RECALC",OF_RECALC,NULL},
};

/* WARNING: untested. -d3p988 30 Jan 08 */
int object_get_oflags(KEYWORD **extflags){
    int flag_size = sizeof(oflags);
    *extflags = malloc(flag_size);
    if(extflags == NULL){
        errno = ENOMEM;
        return -1;
    }
    memcpy(*extflags, oflags, flag_size);
    return flag_size/sizeof(KEYWORD); /* number of items written */
}

/* prototypes */
void object_tree_delete(OBJECT *obj, OBJECTNAME name);

PROPERTY *object_flag_property(void)
{
    static PROPERTY flags = {0, "flags", PT_set, 1, PA_PUBLIC, NULL, (void*)-4, NULL, oflags, NULL};
    return &flags;
}

unsigned int object_get_count(void)
{
    return next_object_id - deleted_object_count;
}

PROPERTY *object_get_property(OBJECT *obj, 
                              PROPERTYNAME name) 
{
    PROPERTY *prop;
    if (obj==NULL) return NULL;
    for (prop=class_get_first_property(obj->oclass); prop!=NULL && obj->oclass->type==prop->otype; prop=prop->next)
    {
        if (strcmp(prop->name,name)==0)
            return prop;
    }
    return NULL;
}


int object_build_object_array(){
    unsigned int tcount = object_get_count();
    unsigned int i = 0;
    OBJECT *optr = object_get_first();
    if(object_array != NULL)
        free(object_array);
    object_array = malloc(sizeof(OBJECT *) * tcount);
    if(object_array == NULL)
        return 0;
    object_array_size = tcount;
    for(i = 0; i < tcount; ++i){
        object_array[i] = optr;
        optr = optr->next;
    }
    return object_array_size;
}

OBJECT *object_find_by_id(OBJECTNUM id) 
{
    OBJECT *obj;
    if(object_get_count() == object_array_size){
        if(id < object_array_size)
            return object_array[id];
        else
            return NULL;
    } else {
        /* this either fails or sets object_array_size to object_get_count() */
        if(object_build_object_array())
            return object_find_by_id(id);
    }
    for (obj=first_object; obj!=NULL; obj=obj->next)
    {
        if (obj->id==id)
            return obj;
    }
    return NULL;
}


char *object_name(OBJECT *obj) 
{
    static char32 oname="(invalid)";
    convert_from_object(oname,sizeof(oname),&obj,NULL);
    return oname;
}

char *object_get_unit(OBJECT *obj, char *name)
{
    static UNIT *dimless=NULL;
    PROPERTY *prop = object_get_property(obj,name);
    if (prop==NULL)
        throw_exception("property '%s' not found in object '%s'", name, object_name(obj));
    if (dimless==NULL)
        dimless=unit_find("1");
    return prop->unit?prop->unit->name:dimless->name;
}

OBJECT *object_create_single(CLASS *oclass, 
                             OBJECTSIZE size) 
{
    OBJECT *obj = (OBJECT*)malloc(sizeof(OBJECT)+size);
    memset(obj, 0, sizeof(OBJECT)+size);
    if (obj==NULL)
    {
        errno = ENOMEM;
        return 0;
    }
    obj->id = next_object_id++;
    obj->size = size;
    obj->oclass = oclass;
    obj->next = NULL;
    obj->name = NULL;
    obj->parent = NULL;
    obj->rank = 0;
    obj->clock = 0;
    obj->latitude = QNAN;
    obj->longitude = QNAN;
    obj->in_svc = TS_ZERO;
    obj->out_svc = TS_NEVER;
    obj->flags = OF_NONE;
    if (first_object==NULL)
        first_object = obj;
    else
        last_object->next = obj;
    last_object = obj;
    oclass->profiler.numobjs++;
    return obj;
}

OBJECT *object_create_array(CLASS *oclass, 
                            OBJECTSIZE size, 
                            unsigned int n_objects) 
{
    OBJECT *first = NULL;
    while (n_objects-->0)
    {
        OBJECT *obj = object_create_single(oclass,size);
        if (obj==NULL)
            return NULL;
        else if (first==NULL)
            first = obj;
    }
    return first;
}

OBJECT *object_remove_by_id(OBJECTNUM id){
    //output_error("object_remove_by_id not yet supported");
    OBJECT *target = object_find_by_id(id);
    OBJECT *prev = NULL;
    OBJECT *next = NULL;
    if(target != NULL){
        char name[64]="";
        if(first_object == target){
            first_object = target->next;
        } else {
            for(prev = first_object; (prev->next != NULL) && (prev->next != target); prev = prev->next){
                ; /* find the object that points to the item being removed */
            }
        }
        object_tree_delete(target, target->name?target->name:(sprintf(name,"%s:%d",target->oclass->name,target->id),name));
        next = target->next;
        prev->next = next;
        target->oclass->profiler.numobjs--;
        free(target);
        deleted_object_count++;
    }
    return next;
}

void *object_get_addr(OBJECT *obj, 
                      char *name) 
{
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && strcmp(name,prop->name)==0)
            return (void*)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    }
    errno = ENOENT;
    return NULL;
}

OBJECT *object_get_object(OBJECT *obj, PROPERTY *prop)
{
    int64 o=(int64)obj, s=(int64)sizeof(OBJECT), a=(int64)(prop->addr);
    int64 i = o+s+a;
    if (obj->oclass->type == prop->otype && prop->ptype == PT_object){
        return *(OBJECT **)i; /* warning: cast from pointer to integer of different size */
    }
    errno = ENOENT;
    return NULL;
}

OBJECT *object_get_object_by_name(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type == prop->otype && prop->ptype == PT_object)
        return (OBJECT *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a 16-bit integer property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
int16 *object_get_int16(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type == prop->otype && prop->ptype == PT_int16)
        return (int16 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

int16 *object_get_int16_by_name(OBJECT *obj, char *name){
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_int16 && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return (int16 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a 32-bit integer property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
int32 *object_get_int32(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type == prop->otype && prop->ptype == PT_int32)
        return (int32 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

int32 *object_get_int32_by_name(OBJECT *obj, char *name){
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_int32 && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return (int32 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a 64-bit integer property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
int64 *object_get_int64(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type == prop->otype && prop->ptype == PT_int64)
        return (int64 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

int64 *object_get_int64_by_name(OBJECT *obj, char *name){
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_int64 && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return (int64 *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a double property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
double *object_get_double_quick(OBJECT *obj, PROPERTY *prop)
{   /* no checks */
    return (double*)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr));
}
double *object_get_double(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type==prop->otype && prop->ptype==PT_double && prop->access != PA_PRIVATE)
        return (double*)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

double *object_get_double_by_name(OBJECT *obj, char *name){
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_double && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return (double *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a complex property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
complex *object_get_complex_quick(OBJECT *obj, PROPERTY *prop)
{   /* no checks */
    return (complex*)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
}
complex *object_get_complex(OBJECT *obj, PROPERTY *prop)
{
    if (obj->oclass->type==prop->otype && prop->ptype==PT_complex && prop->access != PA_PRIVATE)
        return (complex*)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

complex *object_get_complex_by_name(OBJECT *obj, char *name){
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_complex && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return (complex *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

char *object_get_string(OBJECT *obj, PROPERTY *prop){
    if (obj->oclass->type==prop->otype && prop->ptype >= PT_char8 && prop->ptype <= PT_char1024 && prop->access != PA_PRIVATE)
        return (char *)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    errno = ENOENT;
    return NULL;
}

/* Get the pointer to the value of a string property. 
 * Returns NULL if the property is not found or if the value the right type.
 */
char *object_get_string_by_name(OBJECT *obj, char *name)
{
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype>=PT_char8 && prop->ptype<=PT_char1024 && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE){
                return NULL;
            } else {
                return ((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

/* this function finds the property associated with the addr of an object member */
static PROPERTY *get_property_at_addr(OBJECT *obj, void *addr)
{
    static PROPERTY *prop = NULL;
    int64 offset = (int)((char*)addr - (char*)(obj+1));

    /* reuse last result if possible */
    if (prop!=NULL && obj->oclass->pmap->otype==prop->otype && (int64)(prop->addr)==offset && prop->access != PA_PRIVATE)  /* warning: cast from pointer to integer of different size */
        return prop;

    /* scan through properties of this class and stop when no more properties or class changes */
    for (prop=obj->oclass->pmap; prop!=NULL; prop=(prop->next->otype==prop->otype?prop->next:NULL))
    {
        if ((int64)(prop->addr)==offset) /* warning: cast from pointer to integer of different size */
            if(prop->access != PA_PRIVATE)
                return prop;
            else {
                output_error("trying to get the private property %s in %s", prop->name, obj->oclass->name);
                return 0;
            }
    }
    return NULL;
}

int object_set_value_by_addr(OBJECT *obj, 
                             void *addr, 
                             char *value, 
                             PROPERTY *prop) 
{
    int result=0;
    if (prop==NULL && (prop=get_property_at_addr(obj,addr))==NULL) 
        return 0;
    if(prop->access != PA_PUBLIC){
        output_error("trying to set the value of non-public property %s in %s", prop->name, obj->oclass->name);
        return 0;
    }

    /* set the recalc bit if the property has a recalc trigger */
    if (prop->flags&PF_RECALC) obj->flags |= OF_RECALC;

    /* dispatch notifiers */
    if (obj->oclass->notify){
        if(obj->oclass->notify(obj,NM_PREUPDATE,addr) == 0){
            output_error("preupdate notify failure on %s in %s", prop->name, obj->name ? obj->name : "an unnamed object");
        }
    }
    result = class_string_to_property(prop,addr,value);
    if (obj->oclass->notify){
        if(obj->oclass->notify(obj,NM_POSTUPDATE,addr) == 0){
            output_error("postupdate notify failure on %s in %s", prop->name, obj->name ? obj->name : "an unnamed object");
        }
    }
    return result;
}

static int set_header_value(OBJECT *obj, char *name, char *value)
{
    if (strcmp(name,"name")==0)
    {
        if (obj->name!=NULL)
        {
            output_error("object %s:d name already set to %s", obj->oclass->name, obj->id, obj->name);
            return FAILED;
        }
        else
        {
            object_set_name(obj,value);
            return SUCCESS;
        }
    }
    else if (strcmp(name,"parent")==0)
    {
        OBJECT *parent=object_find_name(value);
        if (parent==NULL && strcmp(value,"")!=0)
        {
            output_error("object %s:%d parent %s not found", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else if (object_set_parent(obj,parent)==FAILED && strcmp(value,"")!=0)
        {
            output_error("object %s:%d cannot use parent %s", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else
            return SUCCESS;
    }
    else if (strcmp(name,"rank")==0)
    {
        if (object_set_rank(obj,atoi(value))<0)
        {
            output_error("object %s:%d rank '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else
            return SUCCESS;
    }
    else if (strcmp(name,"clock")==0)
    {
        if ((obj->clock = convert_to_timestamp(value))==TS_INVALID)
        {
            output_error("object %s:%d clock timestamp '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else
            return SUCCESS;
    }
    else if (strcmp(name,"latitude")==0)
    {
        if ((obj->latitude = convert_to_latitude(value))==QNAN)
        {
            output_error("object %s:%d latitude '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else 
            return SUCCESS;
    }
    else if (strcmp(name,"longitude")==0)
    {
        if ((obj->longitude = convert_to_longitude(value))==QNAN)
        {
            output_error("object %s:d longitude '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else 
            return SUCCESS;
    }
    else if (strcmp(name,"in_svc")==0)
    {
        if ((obj->in_svc = convert_to_timestamp(value))==TS_INVALID)
        {
            output_error("object %s:%d in_svc timestamp '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else
            return SUCCESS;
    }
    else if (strcmp(name,"out_svc")==0)
    {
        if ((obj->out_svc = convert_to_timestamp(value))==TS_INVALID)
        {
            output_error("object %s:%d out_svc timestamp '%s' is invalid", obj->oclass->name, obj->id, value);
            return FAILED;
        }
        else
            return SUCCESS;
    }
    else if (strcmp(name,"flags")==0)
    {
        /* flags should be ignored */
        return SUCCESS;
    }
    else
        return FAILED;
    /* should never get here */
}

int object_set_value_by_name(OBJECT *obj, 
                             PROPERTYNAME name, 
                             char *value) 
{
    PROPERTY *prop;
    void *addr;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && strcmp(name,prop->name)==0)
            break;
    }
    if ((prop==NULL || prop->otype!=obj->oclass->type))
    {
        if (set_header_value(obj,name,value)==FAILED)
        {
            errno = ENOENT;
            return 0;
        }
        else
        {
            size_t len = strlen(value);
            return len>0?(int)len:1; /* empty string is not necessarily wrong */
        }
    }
    if(prop->access != PA_PUBLIC){
        output_error("trying to set the value of non-public property %s in %s", prop->name, obj->oclass->name);
        return 0;
    }
    addr = (void*)((char *)(obj+1)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    return object_set_value_by_addr(obj,addr,value,prop);
}

/* Set a property value by reference to its name
 */
int object_set_double_by_name(OBJECT *obj, PROPERTYNAME name, double value)
{
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && prop->ptype==PT_double && strcmp(name,prop->name)==0)
            break;
    }
    if (prop==NULL || prop->otype!=obj->oclass->type )
    {
        errno = ENOENT;
        return 0;
    }
    if(prop->access != PA_PUBLIC){
        output_error("trying to set the value of non-public property %s in %s", prop->name, obj->oclass->name);
        return 0;
    }
    *(double*)((char *)(obj+1)+(int64)(prop->addr)) = value; /* warning: cast from pointer to integer of different size */
    return 1;
}

int object_get_value_by_addr(OBJECT *obj, 
                             void *addr, 
                             char *value, 
                             int size, 
                             PROPERTY *prop) 
{
    prop = prop ? prop : get_property_at_addr(obj,addr);
    if(prop->access == PA_PRIVATE){
        output_error("trying to read the value of private property %s in %s", prop->name, obj->oclass->name);
        return 0;
    }
    return class_property_to_string(prop,addr,value,size);
}

int object_get_value_by_name(OBJECT *obj, PROPERTYNAME name, char *value, int size)
{
    char *buffer = object_property_to_string(obj,name);
    if (buffer==NULL)
        return 0;
    strncpy(value,buffer,size);
    return 1;
}

OBJECT *object_get_reference(OBJECT *obj, char *name)
{
    PROPERTY *prop;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && strcmp(name,prop->name)==0){
            if(prop->access == PA_PRIVATE || prop->ptype!=PT_object)
            {
                errno = EINVAL;
                return NULL;
            } else {
                return *(OBJECT**)((char*)obj+sizeof(OBJECT)+(int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
            }
        }
    }
    errno = ENOENT;
    return NULL;
}

OBJECT *object_get_first()
{
    return first_object;
}

OBJECT *object_get_next(OBJECT *obj) 
{
    return obj!=NULL ? obj->next : NULL;
}


/*  Set the rank of the object (internal use only) 
    This function keeps track of which object initiated
    the request to prevent looping.  This will prevent
    an object_set_parent call from creating a parent loop.
 */
static int set_rank(OBJECT *obj, OBJECTRANK rank, OBJECT *first)
{
    OBJECTRANK parent_rank = -1;
    if (rank >= object_get_count()){
        output_error("%s: set_rank wigging out, rank > object count", object_name(first));
        return -1;
    }
    if (obj==first)
    {
        output_error("%s: set_rank failed, parent loopback has occurred", object_name(first));
        return -1;
    }
    if (obj->flags & OF_RERANK){
        output_error("%s: object flaged as already re-ranked", object_name(obj));
        return -1;
    } else {
        obj->flags += OF_RERANK;
    }
    if (rank >= obj->rank)
        obj->rank = rank+1;
    if (obj->parent != NULL)
    {
        parent_rank = set_rank(obj->parent,obj->rank,first?first:obj);
    }
    obj->flags -= OF_RERANK;
    return obj->rank;
}

int object_set_rank(OBJECT *obj, 
                    OBJECTRANK rank) 
{
    /* prevent rank from decreasing */
    if(obj == NULL)
        return 0;
    if (rank<=obj->rank)
        return obj->rank;
    return set_rank(obj,rank,NULL);
}

int object_set_parent(OBJECT *obj, 
                      OBJECT *parent) 
{
    if(obj == parent)
        return -1;
    obj->parent = parent;
    if (parent!=NULL)
        return set_rank(parent,obj->rank,NULL);
    return obj->rank;
}

int object_set_dependent(OBJECT *obj, 
                         OBJECT *dependent) 
{
    if(obj == dependent)
        return -1;
    return set_rank(dependent,obj->rank,NULL);
}

/* Convert the value of an object property to a string
 * Note that this function uses a single static buffer.
 */
char *object_property_to_string(OBJECT *obj, char *name)
{
    static char buffer[4096];
    PROPERTY *prop;
    void *addr;
    for (prop=obj->oclass->pmap; prop!=NULL && prop->otype==obj->oclass->type; prop=prop->next)
    {
        if (obj->oclass->type==prop->otype && strcmp(name,prop->name)==0)
            break;
    }
    if (prop==NULL || prop->otype!=obj->oclass->type)
    {
        errno = ENOENT;
        return NULL;
    }
    addr = GETADDR(obj,prop); /* warning: cast from pointer to integer of different size */
    if (prop->ptype==PT_delegated)
        return prop->delegation->to_string(addr,buffer,sizeof(buffer))?buffer:NULL;
    else if (class_property_to_string(prop,addr,buffer,sizeof(buffer)))
    {
        if (prop->unit!=NULL)
        {
            strcat(buffer," ");
            strcat(buffer,prop->unit->name);
        }
        return buffer;
    }
    else
        return "";
}

TIMESTAMP object_sync(OBJECT *obj, 
                      TIMESTAMP ts, 
                      PASSCONFIG pass) 
{
    clock_t t=clock();
    register TIMESTAMP plc_time=TS_NEVER, sync_time;
    
    /* call recalc if recalc bit is set */
    if ( (obj->flags&OF_RECALC) && obj->oclass->recalc!=NULL)
    {
        obj->oclass->recalc(obj);
        obj->flags &= ~OF_RECALC;
    }

    /* call PLC code on bottom-up, if any */
    if ( !(obj->flags&OF_HASPLC) && obj->oclass->plc!=NULL && pass==PC_BOTTOMUP ) 
        plc_time = obj->oclass->plc(obj,ts);

    /* call sync */
    sync_time = (*obj->oclass->sync)(obj,ts,pass);

    /* do profiling, if needed */
    if (global_profiler==1)
    {
        obj->oclass->profiler.count++;
        obj->oclass->profiler.clocks += clock()-t;
    }
    sync_time = min(plc_time,sync_time);
    if (sync_time>TS_MAX)
        return TS_NEVER;
    else
        return sync_time;
}

int object_init(OBJECT *obj) 
{
    if (obj->oclass->init!=NULL)
        return (int)(*(obj->oclass->init))(obj,obj->parent);
    return 1;
}

int object_isa(OBJECT *obj, 
               char *type) 
{
    if (strcmp(obj->oclass->name,type)==0)
        return 1;
    else if (obj->oclass->isa)
        return (int)obj->oclass->isa(obj,type);
    else
        return 0;
}

int object_dump(char *outbuffer, 
                int size, 
                OBJECT *obj) 
{
    char buffer[65536];
    char tmp[256];
    int count = 0;
    PROPERTY *prop;
    static int safesize;
    if (size>sizeof(buffer))
        size = sizeof(buffer);
    safesize = size;

    count += sprintf(buffer+count,"object %s:%d {\n", obj->oclass->name, obj->id);

    /* dump internal properties */
    if (obj->parent!=NULL)
        count += sprintf(buffer+count,"\tparent = %s:%d (%s)\n", obj->parent->oclass->name, obj->parent->id, obj->parent->name!=NULL?obj->parent->name:"");
    else
        count += sprintf(buffer+count,"\troot object\n");
    if (obj->name!=NULL)
        count += sprintf(buffer+count,"\tname %s\n",obj->name);
    count += sprintf(buffer+count,"\trank = %d;\n", obj->rank);
    count += sprintf(buffer+count,"\tclock = %s (%" FMT_INT64 "d);\n", convert_from_timestamp(obj->clock,tmp,sizeof(tmp))>0?tmp:"(invalid)",obj->clock);
    if (!isnan(obj->latitude)) count += sprintf(buffer+count,"\tlatitude = %s;\n",convert_from_latitude(obj->latitude,tmp,sizeof(tmp))?tmp:"(invalid)");
    if (!isnan(obj->longitude)) count += sprintf(buffer+count,"\tlongitude = %s;\n",convert_from_longitude(obj->longitude,tmp,sizeof(tmp))?tmp:"(invalid)");
    count += sprintf(buffer+count,"\tflags = %s;\n", convert_from_set(tmp,sizeof(tmp),&(obj->flags),object_flag_property())?tmp:"(invalid)");

    /* dump properties */
    for (prop=obj->oclass->pmap;prop!=NULL && prop->otype==obj->oclass->type;prop=prop->next)
    {
        char *value = object_property_to_string(obj,prop->name);
        if (value!=NULL)
            count += sprintf(buffer+count,"\t%s %s = %s;\n",prop->ptype==PT_delegated?prop->delegation->type:class_get_property_typename(prop->ptype),prop->name,value);
        if (count>safesize)
            throw_exception("object_dump(char *buffer=%x, int size=%d, OBJECT *obj=%s:%d) buffer overrun", outbuffer,size,obj->oclass->name,obj->id);
    }
    count += sprintf(buffer+count,"}\n");
    if(count < size && count < sizeof(buffer)){
        strncpy(outbuffer, buffer, count+1);
        return count;
    } else {
        output_error("buffer too small in object_dump()!");
        return 0;
    }
    
}

int object_saveall(FILE *fp) 
{
    unsigned count=0;
    char buffer[1024];
    count += fprintf(fp,"\n########################################################\n");
    count += fprintf(fp,"# objects\n");
    {   OBJECT *obj;
        for (obj=first_object; obj!=NULL; obj=obj->next)
        {
            PROPERTY *prop;
            char32 oname="(unidentified)";
            count += fprintf(fp,"object %s:%d {\n", obj->oclass->name, obj->id);

            /* dump internal properties */
            if (obj->parent!=NULL)
            {
                convert_from_object(oname,sizeof(oname),&obj->parent,NULL);
                count += fprintf(fp,"\tparent %s;\n", oname);
            }
            else
                count += fprintf(fp,"\troot;\n");
            count += fprintf(fp,"\trank %d;\n", obj->rank);
            if (obj->name!=NULL)
                count += fprintf(fp,"\tname %s;\n", obj->name);
            count += fprintf(fp,"\tclock %s;\n", convert_from_timestamp(obj->clock,buffer,sizeof(buffer))>0?buffer:"(invalid)");
            if (!isnan(obj->latitude)) count += fprintf(fp,"\tlatitude %s;\n",convert_from_latitude(obj->latitude,buffer,sizeof(buffer))?buffer:"(invalid)");
            if (!isnan(obj->longitude)) count += fprintf(fp,"\tlongitude %s;\n",convert_from_longitude(obj->longitude,buffer,sizeof(buffer))?buffer:"(invalid)");
            count += fprintf(fp,"\tflags %s;\n", convert_from_set(buffer,sizeof(buffer),&(obj->flags),object_flag_property())?buffer:"(invalid)");
            /* dump properties */
            for (prop=obj->oclass->pmap;prop!=NULL && prop->otype==obj->oclass->type;prop=prop->next)
            {
                char *value = object_property_to_string(obj,prop->name);
                if (value!=NULL)
                    count += fprintf(fp,"\t%s %s;\n",prop->name,value);
            }
            count += fprintf(fp,"}\n");
        }
    }
    return count;   
}

int object_saveall_xml(FILE *fp) 
{
    unsigned count = 0;
    char buffer[1024];
    PROPERTY *prop = NULL;
    OBJECT *obj;
    CLASS *oclass=NULL;

    for(obj = first_object; obj != NULL; obj = obj->next){

        char32 oname = "(unidentified)";
        convert_from_object(oname, sizeof(oname), &obj, NULL); /* what if we already have a name? -mh */
        if ((oclass == NULL) || (obj->oclass->type != oclass->type))
            oclass = obj->oclass;
        count += fprintf(fp,"\t\t<object type=\"%s\" id=\"%i\" name=\"%s\">\n", obj->oclass->name, obj->id, oname);

        /* dump internal properties */
        if (obj->parent!=NULL)
        {
            convert_from_object(oname,sizeof(oname),&obj->parent,NULL);
            count += fprintf(fp,"\t\t\t<parent>\n"); 
            count += fprintf(fp, "\t\t\t\t%s\n", oname);
            count += fprintf(fp,"\t\t\t</parent>\n");
        }
        else
            count += fprintf(fp,"\t\t\t<parent>root</parent>\n");
            count += fprintf(fp,"\t\t\t<rank>%d</rank>\n", obj->rank);
            count += fprintf(fp,"\t\t\t<clock>\n", obj->clock);
            count += fprintf(fp,"\t\t\t\t <timestamp>%s</timestamp>\n", convert_from_timestamp(obj->clock,buffer,sizeof(buffer))>0?buffer:"(invalid)");
            count += fprintf(fp,"\t\t\t</clock>\n");
            /* why do latitude/longitude have 2 values?  I currently only store as float in the schema... */
        if (!isnan(obj->latitude)) 
            count += fprintf(fp,"\t\t\t<latitude>%lf %s</latitude>\n",obj->latitude,convert_from_latitude(obj->latitude,buffer,sizeof(buffer))?buffer:"(invalid)");
        if (!isnan(obj->longitude)) 
            count += fprintf(fp,"\t\t\t<longitude>%lf %s</longitude>\n",obj->longitude,convert_from_longitude(obj->longitude,buffer,sizeof(buffer))?buffer:"(invalid)");

        /* dump properties */
        for (prop=oclass->pmap;prop!=NULL && prop->otype==oclass->type;prop=prop->next)
        {
            char *value = object_property_to_string(obj,prop->name);
            if (value!=NULL){
                count += fprintf(fp, "\t\t\t<%s>%s</%s>\n", prop->name, value, prop->name);
            }
        }
        count += fprintf(fp,"\t\t</object>\n");
    }

    count += fprintf(fp,"\t</objects>\n");
    return count;   
}

int object_saveall_xml_old(FILE *fp);

int object_saveall_xml_old(FILE *fp) 
{
    unsigned count=0;
    char buffer[1024];
    count += fprintf(fp,"\t<objects>\n");
    {   OBJECT *obj;
        CLASS *oclass=NULL;
        for (obj=first_object; obj!=NULL; obj=obj->next)
        {
            PROPERTY *prop;
            char32 oname="(unidentified)";
            convert_from_object(oname,sizeof(oname),&obj,NULL);
            if (oclass==NULL || obj->oclass->type!=oclass->type)
                oclass = obj->oclass;
            count += fprintf(fp,"\t\t<object>\n");
            count += fprintf(fp,"\t\t\t<name>%s</name> \n", oname);
            count += fprintf(fp,"\t\t\t<class>%s</class> \n", obj->oclass->name);
            count += fprintf(fp, "\t\t\t<id>%d</id>\n", obj->id);

            /* dump internal properties */
            if (obj->parent!=NULL)
            {
                convert_from_object(oname,sizeof(oname),&obj->parent,NULL);
                count += fprintf(fp,"\t\t\t<parent>\n"); 
                count += fprintf(fp,"\t\t\t\t<name>%s</name>\n", oname);
                count += fprintf(fp,"\t\t\t\t<class>%s</class>\n", obj->parent->oclass->name);
                count += fprintf(fp,"\t\t\t\t<id>%d</id>\n", obj->parent->id);
                count += fprintf(fp,"\t\t\t</parent>\n");
            }
            else
                count += fprintf(fp,"\t\t\t<parent>root</parent>\n");
                count += fprintf(fp,"\t\t\t<rank>%d</rank>\n", obj->rank);
                count += fprintf(fp,"\t\t\t<clock>\n", obj->clock);
                count += fprintf(fp,"\t\t\t\t <timestamp>%s</timestamp>\n", convert_from_timestamp(obj->clock,buffer,sizeof(buffer))>0?buffer:"(invalid)");
                count += fprintf(fp,"\t\t\t</clock>\n");
                /* why do latitude/longitude have 2 values?  I currently only store as float in the schema... */
            if (!isnan(obj->latitude)) 
                count += fprintf(fp,"\t\t\t<latitude>%lf %s</latitude>\n",obj->latitude,convert_from_latitude(obj->latitude,buffer,sizeof(buffer))?buffer:"(invalid)");
            if (!isnan(obj->longitude)) 
                count += fprintf(fp,"\t\t\t<longitude>%lf %s</longitude>\n",obj->longitude,convert_from_longitude(obj->longitude,buffer,sizeof(buffer))?buffer:"(invalid)");

            /* dump properties */
            count += fprintf(fp,"\t\t\t<properties>\n");
            for (prop=oclass->pmap;prop!=NULL && prop->otype==oclass->type;prop=prop->next)
            {
                char *value = object_property_to_string(obj,prop->name);
                if (value!=NULL)
                    count += fprintf(fp,"\t\t\t\t<property>\n");
                count += fprintf(fp,"\t\t\t\t\t<type>%s</type> \n", prop->name);
                    count += fprintf(fp,"\t\t\t\t\t<value>%s</value> \n", value);
                    count += fprintf(fp,"\t\t\t\t</property>\n");
            }
            count += fprintf(fp,"\t\t\t</properties>\n");
            count += fprintf(fp,"\t\t</object>\n");
        }
    }
    count += fprintf(fp,"\t</objects>\n");
    return count;   
}

int convert_from_latitude(double v,void *buffer,int bufsize)
{
    double d = floor(fabs(v));
    double r = fabs(v)-d;
    double m = floor(r*60);
    double s = (r - (double)m/60.0)*3600;
    char ns = v<0 ? 'S':'N';
    if(isnan(v)) return 0;
    return sprintf(buffer,"%.0f%c%.0f'%.2f\"",d,ns,m,s);
}

int convert_from_longitude(double v,void *buffer,int bufsize)
{
    double d = floor(fabs(v));
    double r = fabs(v)-d;
    double m = floor(r*60);
    double s = (r - (double)m/60.0)*3600;
    char ns = v<0 ? 'W':'E';
    if(isnan(v)) return 0;
    return sprintf(buffer,"%.0f%c%.0f'%.2f\"",d,ns,m,s);
}

double convert_to_latitude(char *buffer)
{
    int32 d, m=0;
    double s=0;
    char ns;
    if (sscanf(buffer,"%d%c%d'%lf\"",&d,&ns,&m,&s)>1)
    {   
        double v = (double)d+(double)m/60+s/3600;
        if (v>=0 || v<=90)
        {
            if (ns=='S')
                return -v;
            else if (ns=='N')
                return v;
        }
    }
    return QNAN;
}

double convert_to_longitude(char *buffer)
{
    int32 d, m=0;
    double s=0;
    char ns;
    if (sscanf(buffer,"%d%c%d'%lf\"",&d,&ns,&m,&s)>1)
    {   
        double v = (double)d+(double)m/60+s/3600;
        if (v>=0 || v<=90)
        {
            if (ns=='W')
                return -v;
            else if (ns=='E')
                return v;
        }
    }
    return QNAN;
}

/***************************************************************************
 OBJECT NAME TREE
 ***************************************************************************/

typedef struct s_objecttree {
    char name[32];
    OBJECT *obj;
    struct s_objecttree *before, *after;
    int balance; /* unused */
} OBJECTTREE;

static OBJECTTREE *top=NULL;

void debug_traverse_tree(OBJECTTREE *tree){
    if(tree == NULL){
        tree = top;
        if(top == NULL)
            return;
    }
    if(tree->before != NULL) debug_traverse_tree(tree->before);
    output_test("%s", tree->name);
    if(tree->after != NULL) debug_traverse_tree(tree->after);
}

/* returns the height of the tree */
int tree_get_height(OBJECTTREE *tree){
    if(tree == NULL){
        return 0;
    } else {
        int left = tree_get_height(tree->before);
        int right = tree_get_height(tree->after);
        if(left > right)
            return left+1;
        else return right+1;
    }
}

/* returns the node to point to instead of tree */
void rotate_tree_right(OBJECTTREE **tree){ /* move one object from left to right */
    OBJECTTREE *root, *pivot, *child;
    root = *tree;
    pivot = root->before;
    child = root->before->after;
    *tree = pivot;
    pivot->after = root;
    root->before = child;
    root->balance += 2;
    pivot->balance += 1;
}

/* returns the node to point to instead of tree */
void rotate_tree_left(OBJECTTREE **tree){ /* move one object from right to left */
    OBJECTTREE *root, *pivot, *child;
    root = *tree;
    pivot = root->after;
    child = root->after->before;
    *tree = pivot;
    pivot->before = root;
    root->after = child;
    root->balance -= 2;
    pivot->balance -= 1;
}

/*  Rebalance the tree to make searching more efficient
    It's a good idea to this after the tree is built
 */
int object_tree_rebalance(OBJECTTREE *tree) /* AVL logic */
{
    /* currently being done during insertions & deletions */
    return 0;
}

/*  Add an item to the tree
    returns the "correct" root node for the subtree that an object was added to.
 */
static int addto_tree(OBJECTTREE **tree, OBJECTTREE *item)
{
    int rel = strcmp((*tree)->name, item->name);
    int right = 0, left = 0, ir = 0, il = 0, rv = 0;
    if (rel>0)
    {
        (*tree)->balance--;
        if ((*tree)->before==NULL)
        {
            (*tree)->before = item;
            return 1;
        }
        else {
            rv = addto_tree(&((*tree)->before),item);
            if(global_no_balance) return rv + 1;
            if((*tree)->balance > 1){
                if((*tree)->after->balance < 0){ /* inner left is heavy */
                    rotate_tree_right(&((*tree)->after));
                }
                rotate_tree_left(tree);
            } else if((*tree)->balance < -1){
                if((*tree)->before->balance > 0){ /* inner right is heavy */
                    rotate_tree_left(&((*tree)->before));
                }
                rotate_tree_right(tree);
            }
            return tree_get_height(*tree); /* verify after rotations */
        }
    }
    else if (rel<0)
    {
        (*tree)->balance++;
        if ((*tree)->after==NULL)
        {
            (*tree)->after = item;
            return 1;
        }
        else {
            rv = addto_tree(&((*tree)->after),item);
            if(global_no_balance) return rv + 1;
            if((*tree)->balance > 1){
                if((*tree)->after->balance < 0){ /* inner left is heavy */
                    rotate_tree_right(&((*tree)->after));
                }
                rotate_tree_left(tree); //  was left/right
            } else if((*tree)->balance < -1){
                if((*tree)->before->balance > 0){ /* inner right is heavy */
                    rotate_tree_left(&((*tree)->before));
                }
                rotate_tree_right(tree);
            }
            return tree_get_height(*tree); /* verify after rotations */
        }
    }
    else
        return (*tree)->obj==item->obj;
    return 0;
}

/*  Add an object to the object tree.  Throws exceptions on memory errors.
    Returns a pointer to the object tree item if successful, NULL on failure (usually because name already used)
 */
static OBJECTTREE *object_tree_add(OBJECT *obj, OBJECTNAME name)
{
    OBJECTTREE *item = (OBJECTTREE*)malloc(sizeof(OBJECTTREE));
    if (item==NULL) 
        throw_exception("object_tree_add(obj='%s:%d', name='%s'): memory allocation failed (%s)",
            obj->oclass->name, obj->id, name, strerror(errno));
    item->obj = obj;
    item->balance = 0;
    strncpy(item->name,name,sizeof(item->name));
    item->before=item->after=NULL;
    if (top==NULL)
    {
        top = item;
        return top;
    }
    else{
        return addto_tree(&top,item) ? item : NULL;
    }
}

/*  Finds a name in the tree
 */
static OBJECTTREE **findin_tree(OBJECTTREE *tree, OBJECTNAME name)
{
    static OBJECTTREE **temptree = NULL;
    if (tree==NULL)
        return NULL;
    else 
    {
        int rel = strcmp(tree->name,name);
        if (rel>0)
        {
            if(tree->before != NULL){
                if(strcmp(tree->before->name, name) == 0)
                    return &(tree->before);
                else
                    return findin_tree(tree->before, name);
            } else {
                return NULL;
            }
        }
        else if (rel<0)
        {
            if(tree->after != NULL){
                if(strcmp(tree->after->name, name) == 0)
                    return &(tree->after);
                else
                    return findin_tree(tree->after, name);
            } else {
                return NULL;
            }
        }
        else
            return (temptree = &tree);
    }
}

/*  Deletes a name from the tree
    WARNING: removing a tree entry does NOT free() its object!
 */
void object_tree_delete(OBJECT *obj, OBJECTNAME name)
{
    OBJECTTREE **item = findin_tree(top,name);
    OBJECTTREE *temp = NULL, **dtemp = NULL;
    if (item!=NULL && strcmp((*item)->name,name)!=0){
        if((*item)->after == NULL && (*item)->before == NULL){ /* no children -- nuke */
            free(*item);
            *item = NULL;
        } else if((*item)->after != NULL && (*item)->before != NULL){ /* two children -- find a replacement */
            dtemp = &((*item)->before);
            while(temp->after != NULL)
                dtemp = &(temp->after);
            temp = (*dtemp)->before;
            (*dtemp)->before = (*item)->before;
            (*dtemp)->after = (*item)->after;
            free(*item);
            *item = *dtemp;
            *dtemp = temp;
            /* replace item with the rightmost left element.*/

        } else if((*item)->after == NULL || (*item)->before == NULL){ /* one child -- promotion time! */
            if((*item)->after != NULL){
                temp = (*item)->after;
                free(*item);
                *item = temp;
            } else if((*item)->before != NULL){
                temp = (*item)->before;
                free(*item);
                *item = temp;
            } else {
                output_fatal("unexpected branch result in object_tree_delete");
            }
        }

        /* throw_exception("object_tree_delete(obj=%s:%d, name='%s'): rename of objects in tree is not supported yet", obj->oclass->name, obj->id, name); */
    }
}

OBJECT *object_find_name(OBJECTNAME name)
{
    OBJECTTREE **item = findin_tree(top,name);
    return item!=NULL && *item!=NULL ? (*item)->obj : NULL;
}

void object_set_name(OBJECT *obj, OBJECTNAME name)
{
    /* the next line of code guards the object against floating w/o a tree. -mh */
    /* if (name == NULL) return; */
    if (obj->name!=NULL)
        object_tree_delete(obj,name);
    if (name!=NULL)
    {
        OBJECTTREE *item = object_tree_add(obj,name);
        obj->name = item->name;
    }
}

void remove_objects()
{ 
    OBJECT* obj1;

    obj1 = first_object;
    while(obj1 != NULL){
        first_object = obj1->next;
        obj1->oclass->profiler.numobjs--;
        free(obj1);
        obj1 = first_object;
    }

    next_object_id = 0;
}

---

GridLAB-D^TM Version 1.0

An open-source project initiated by the US Department of Energy