core/class.c

Go to the documentation of this file.

#include "class.h"
#include "output.h"
#include "convert.h"
#include "module.h"
#include "exception.h"
#include "timestamp.h"

/* IMPORTANT: this list must match PROPERTYTYPE enum in class.h */
static struct s_property_specs { 
    char *name; 
    unsigned int size; 
    int (*data_to_string)(char *,int,void*,PROPERTY*); 
    int (*string_to_data)(char *,void*,PROPERTY*); 
} property_type[] = {
    {"void", 0, convert_from_void,convert_to_void},
    {"double", sizeof(double), convert_from_double,convert_to_double},
    {"complex", sizeof(complex), convert_from_complex,convert_to_complex},
    {"enumeration",sizeof(long), convert_from_enumeration,convert_to_enumeration},
    {"set",sizeof(int64), convert_from_set,convert_to_set},
    {"int16", sizeof(int16), convert_from_int16,convert_to_int16},
    {"int32", sizeof(int32), convert_from_int32,convert_to_int32},
    {"int64", sizeof(int64), convert_from_int64,convert_to_int64},
    {"char8", sizeof(char8), convert_from_char8,convert_to_char8},
    {"char32", sizeof(char32), convert_from_char32,convert_to_char32},
    {"char256", sizeof(char256), convert_from_char256,convert_to_char256},
    {"char1024", sizeof(char1024), convert_from_char1024,convert_to_char1024},
    {"object", sizeof(OBJECT*), convert_from_object,convert_to_object},
    {"delegated", -1, convert_from_delegated, convert_to_delegated},
    {"bool", sizeof(unsigned int), convert_from_boolean, convert_to_boolean},
    {"timestamp", sizeof(int64), convert_from_timestamp_stub, convert_to_timestamp_stub},
    {"double_array", sizeof(double), convert_from_double_array, convert_to_double_array},
    {"complex_array", sizeof(complex), convert_from_complex_array, convert_to_complex_array},
};

/* property map */
PROPERTY *first_property = NULL;
PROPERTY *last_property = NULL;

/* object class list */
OBJECTTYPE last_object_type = 0;
static CLASS *first_class = NULL;
static CLASS *last_class = NULL;

PROPERTY *class_get_first_property(CLASS *oclass) 
{
    if (oclass==NULL)
        return first_property;
    else
        return oclass->pmap;
}

PROPERTY *class_get_next_property(PROPERTY *prop)
{
    if (prop->next!=NULL && prop->otype==prop->next->otype)
        return prop->next;
    else
        return NULL;
}

unsigned long property_size(PROPERTY *prop)
{
    if (prop && prop->ptype>_PT_FIRST && prop->ptype<_PT_LAST)
        return property_type[prop->ptype].size;
    else
        return 0;
}
PROPERTY *class_find_property(CLASS *oclass,        
                              PROPERTYNAME name)    
{
    PROPERTY *prop;
    for (prop=oclass->pmap; prop!=NULL && prop->otype==oclass->type; prop=prop->next)
    {
        if (strcmp(name,prop->name)==0)
            return prop;
    }
    return NULL;
}

CLASS *class_get_last_class(void)
{
    return last_class;
}

unsigned int class_get_count(void)
{
    return last_object_type;
}

char *class_get_property_typename(PROPERTYTYPE type) 
{
    if (type<=_PT_FIRST || type>=_PT_LAST)
        return "##UNDEF##";
    else 
        return property_type[type].name;
}

PROPERTYTYPE class_get_propertytype_from_typename(char *name) 
{
    int i;
    for (i=0; i<sizeof(property_type)/sizeof(property_type[0]); i++)
    {
        if (strcmp(property_type[i].name,name)==0)
            return i;
    }
    return PT_void;
}

int class_string_to_property(PROPERTY *prop, 
                             void *addr,        
                             char *value)       
{
    if (prop->ptype==PT_delegated)
    {
        output_error("unable to convert to delegated property value");
        return 0;
    }
    else if (prop->ptype > _PT_FIRST && prop->ptype < _PT_LAST)
        return (*property_type[prop->ptype].string_to_data)(value,addr,prop);
    else
        return 0;
}

int class_property_to_string(PROPERTY *prop, 
                             void *addr,        
                             char *value,       
                             int size)          
{
    if (prop->ptype==PT_delegated)
    {
        output_error("unable to convert from delegated property value");
        return 0;
    }
    else if (prop->ptype>_PT_FIRST && prop->ptype<_PT_LAST)
        return (*property_type[prop->ptype].data_to_string)(value,size,addr,prop);
    else
        return 0;
}


CLASS *class_register(MODULE *module,           
                      CLASSNAME name,           
                      PASSCONFIG passconfig)    
{
    CLASS *oclass = class_get_class_from_classname(name);
    MODULE *mod = NULL;

    /* check the property list */
    int a = sizeof(property_type);
    int b = sizeof(property_type[0]);
    int c = _PT_LAST - _PT_FIRST - 1;

    if (_PT_LAST-_PT_FIRST-1!=sizeof(property_type)/sizeof(property_type[0]))
    {
        output_fatal("property_type[] in class.c has an incorrect number of members");
        exit(1);
    }
    if (oclass!=NULL)
    {
        if(strcmp(oclass->module->name, module->name) == 0){
            output_error("module %s cannot register class %s, it is already registered by module %s", module->name,name,oclass->module->name);
            return NULL;
        } else {
            output_verbose("module %s is registering a 2nd class %s, previous one in module %s", module->name, name, oclass->module->name);
        }
    }
    if (strlen(name)>=sizeof(oclass->name) )
    {
        errno = E2BIG;
        return 0;
    }
    oclass = (CLASS*)malloc(sizeof(CLASS));
    if (oclass==NULL)
    {
        errno = ENOMEM;
        return 0;
    }
    oclass->module = module;
    oclass->type = ++last_object_type;
    strncpy(oclass->name,name,sizeof(oclass->name));
    oclass->next = NULL;
    oclass->pmap = NULL;
    oclass->fmap = NULL;
    oclass->sync = NULL;
    oclass->create = NULL;
    oclass->passconfig = passconfig;
    oclass->profiler.numobjs=0;
    oclass->profiler.count=0;
    oclass->profiler.clocks=0;
    if (first_class==NULL)
        first_class = oclass;
    else
        last_class->next = oclass;
    last_class = oclass;
    output_verbose("class %s registered ok", name);
    return oclass;
}

CLASS *class_get_first_class(void)
{
    return first_class;
}

CLASS *class_get_class_from_objecttype(OBJECTTYPE type) 
{
    CLASS *oclass;
    for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
    {
        if (oclass->type==type)
            return oclass;
    }
    return NULL;
}

char *class_get_classname_from_objecttype(OBJECTTYPE type) 
{
    CLASS *oclass;
    for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
    {
        if (oclass->type==type)
            return oclass->name;
    }
    return NULL;
}

CLASS *class_get_class_from_classname_in_module(char *name, MODULE *mod){
    CLASS *oclass = NULL;
    if(name == NULL) return NULL;
    if(mod == NULL) return NULL;
    for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
    {
        if(oclass->module == (MODULE *)mod)
            if(strcmp(oclass->name,name)==0)
                return oclass;
    }
    return NULL;
}

CLASS *class_get_class_from_classname(char *name) 
{
    CLASS *oclass = NULL;
    MODULE *mod = NULL;
    char *ptr = NULL;
    char temp[1024]; /* we get access violations when name is from another DLL. -mh */
    strcpy(temp, name);
    ptr = strchr(temp, '.');
    if(ptr != NULL){    /* check module for the class */
        ptr[0] = 0;
        ++ptr;
        mod = module_find(temp);
        if(mod == NULL){
            output_verbose("could not search for '%s.%s', module not loaded", name, ptr);
            return NULL;
        }
        for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
        {
            if(oclass->module == mod)
                if(strcmp(oclass->name,ptr)==0)
                    return oclass;
        }
        return NULL;
    }
    for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
    {
        if (strcmp(oclass->name,name)==0)
            return oclass;
    }
    return NULL;
}

OBJECTTYPE class_get_classtype_from_classname(char *name) 
{
    CLASS *oclass;
    for (oclass=first_class; oclass!=NULL; oclass=oclass->next)
    {
        if (strcmp(oclass->name,name)==0)
            return oclass->type;
    }
    return 0;
}

int class_define_map(CLASS *oclass, 
                     ...) 
{
    va_list arg;
    PROPERTYTYPE proptype;
    int count=0;
    PROPERTY *prop=NULL;
    va_start(arg,oclass);
    while ((proptype=va_arg(arg,PROPERTYTYPE))!=0)
    {
        if (proptype>_PT_LAST)
        {
            if (prop==NULL)
            {
                errno = EINVAL;
                output_error("class_map_define(): expected keyword missing after '%s'", class_get_property_typename(proptype));
                goto Error;
            }
            else if (proptype==PT_KEYWORD && prop->ptype==PT_enumeration)
            {
                char *keyword = va_arg(arg,char*);
                long keyvalue = va_arg(arg,long);
                if (!class_define_enumeration_member(oclass,prop->name,keyword,keyvalue))
                {
                    errno = EINVAL;
                    output_error("class_map_define(): property keyword '%s' could not be defined as value %d", keyword,keyvalue);
                    goto Error;
                }
            }
            else if (proptype==PT_KEYWORD && prop->ptype==PT_set)
            {
                char *keyword = va_arg(arg,char*);
                unsigned long keyvalue = va_arg(arg, int); 
                if (!class_define_set_member(oclass,prop->name,keyword,keyvalue))
                {
                    errno = EINVAL;
                    output_error("class_map_define(): property keyword '%s' could not be defined as value %d", keyword,keyvalue);
                    goto Error;
                }
            }
            else if (proptype==PT_ACCESS)
            {
                PROPERTYACCESS pa = va_arg(arg,PROPERTYACCESS); 
                switch (pa) {
                case PA_PUBLIC:
                case PA_PROTECTED:
                case PA_PRIVATE:
                case PA_REFERENCE:
                    prop->access = pa;
                    break;
                default:
                    errno = EINVAL;
                    output_error("class_map_define(): unrecognized property access code (value=%d is not valid)", pa);
                    goto Error;
                    break;
                }
            }
            else if (proptype==PT_SIZE)
            {
                prop->size = va_arg(arg,unsigned long);
                if (prop->size<1)
                {
                    errno = EINVAL;
                    output_error("class_map_define(): property size must be greater than 0", proptype);
                    goto Error;
                }
            }
            else if (proptype==PT_FLAGS)
            {
                prop->flags = va_arg(arg,unsigned int);
            }
            else
            {
                char tcode[32];
                char *ptypestr=class_get_property_typename(proptype);
                sprintf(tcode,"%d",proptype);
                if (strcmp(ptypestr,"##UNDEF##")==0)
                    ptypestr = tcode;
                errno = EINVAL;
                output_error("class_map_define(): unrecognized extended property (PROPERTYTYPE=%s)", ptypestr?ptypestr:tcode);
                goto Error;
            }
        }

        else
        {
            DELEGATEDTYPE *delegation=(proptype==PT_delegated?va_arg(arg,DELEGATEDTYPE*):NULL);
            char *name = va_arg(arg,char*);
            PROPERTYADDR addr = va_arg(arg,PROPERTYADDR);
            char unitspec[1024];
            if (strlen(name)>=sizeof(prop->name))
            {
                output_error("class_map_define(): property name '%s' is too big", prop->name);
                errno = E2BIG;
                goto Error;
            }
            prop = (PROPERTY*)malloc(sizeof(PROPERTY));
            if (prop==NULL)
            {
                output_error("class_map_define(): memory allocation failed", prop->name);
                errno = ENOMEM;
                goto Error;
            }
            prop->ptype = proptype;
            prop->size = 0;
            prop->access = PA_PUBLIC;
            prop->otype = oclass->type;
            prop->flags = 0;
            prop->keywords = NULL;
            if (sscanf(name,"%[^[][%[A-Za-z0-9*/^]]",prop->name,unitspec)==2)
            {
                prop->unit = unit_find(unitspec);
                if (prop->unit==NULL)
                    output_warning("property %s unit '%s' is not recognized",prop->name,unitspec);
            }
            else
                prop->unit = NULL;
            prop->addr = addr;
            prop->delegation = delegation;
            prop->next = NULL;
            if (first_property==NULL)
                first_property = prop;
            else
                last_property->next = prop;
            last_property = prop;
            
            /* link map to oclass if not yet done */
            if (oclass->pmap==NULL)
                oclass->pmap = prop;
            count++;

            /* save enum property in case extended property come up */
            if (prop->ptype>_PT_LAST)
                prop = NULL;
        }
    }
    va_end(arg);
    return count;
Error:
    if (prop!=NULL)
        output_verbose("class_define_map() processed up to property %s", prop->name);
    return -count;
}

int class_define_enumeration_member(CLASS *oclass, 
                                    char *property_name, 
                                    char *member, 
                                    enumeration value) 
{
    PROPERTY *prop = class_find_property(oclass,property_name);
    KEYWORD *key = (KEYWORD*)malloc(sizeof(KEYWORD));
    if (prop==NULL || key==NULL) return 0;
    key->next = prop->keywords;
    strncpy(key->name,member,sizeof(key->name));
    key->value = value;
    prop->keywords = key;
    return 1;
}

int class_define_set_member(CLASS *oclass, 
                            char *property_name, 
                            char *member, 
                            unsigned long value) 
{
    PROPERTY *prop = class_find_property(oclass,property_name);
    KEYWORD *key = (KEYWORD*)malloc(sizeof(KEYWORD));
    if (prop==NULL || key==NULL) return 0;
    if (prop->keywords==NULL)
        prop->flags |= PF_CHARSET; /* enable single character keywords until a long keyword is defined */
    key->next = prop->keywords;
    strncpy(key->name,member,sizeof(key->name));
    key->name[sizeof(key->name)-1]='\0'; /* null terminate name in case is was too long for strncpy */
    if (strlen(key->name)>1 && (prop->flags&PF_CHARSET)) /* long keyword detected */
        prop->flags ^= PF_CHARSET; /* disable single character keywords */
    key->value = value;
    prop->keywords = key;
    return 1;
}

/* Define a class function.
 */
FUNCTION *class_define_function(CLASS *oclass, FUNCTIONNAME functionname, FUNCTIONADDR call)
{
    FUNCTION *func = (FUNCTION*)malloc(sizeof(FUNCTION));
    if (func==NULL)
    {
        errno = ENOMEM;
        return NULL;
    }
    func->addr = call;
    strcpy(func->name,functionname);
    func->next = NULL;
    func->otype = oclass->type;
    if (oclass->fmap==NULL)
        oclass->fmap = func;
    else
        oclass->fmap->next = func;
    return func;
}

/* Get the entry point of a class function
 */
FUNCTIONADDR class_get_function(char *classname, char *functionname)
{
    CLASS *oclass = class_get_class_from_classname(classname);
    FUNCTION *func;
    for (func=oclass->fmap; func!=NULL && func->otype==oclass->type; func=func->next)
    {
        if (strcmp(functionname,func->name)==0)
            return func->addr;
    }
    errno = ENOENT;
    return NULL;
}

int class_saveall(FILE *fp) 
{
    unsigned count=0;
    count += fprintf(fp,"\n########################################################\n");
    count += fprintf(fp,"# classes\n");
    {   CLASS   *oclass;
        for (oclass=class_get_first_class(); oclass!=NULL; oclass=oclass->next)
        {
            PROPERTY *prop;
            FUNCTION *func;
            count += fprintf(fp,"class %s {\n",oclass->name,oclass->type);
            for (func=oclass->fmap; func!=NULL && func->otype==oclass->type; func=func->next)
                count += fprintf(fp, "\tfunction %s();\n", func->name);
            for (prop=oclass->pmap; prop!=NULL && prop->otype==oclass->type; prop=prop->next)
            {
                char *propname = class_get_property_typename(prop->ptype);
                if (propname!=NULL)
                    count += fprintf(fp,"\t%s %s;\n", propname, prop->name);
            }
            count += fprintf(fp,"}\n");
        }
    }
    return count;
}

int class_saveall_xml(FILE *fp) 
{
    unsigned count=0;
    count += fprintf(fp,"\t<classes>\n");
    {   CLASS   *oclass;
        for (oclass=class_get_first_class(); oclass!=NULL; oclass=oclass->next)
        {
            PROPERTY *prop;
            FUNCTION *func;
            count += fprintf(fp,"\t\t<class name=\"%s\">\n",oclass->name,oclass->type);
            for (func=oclass->fmap; func!=NULL && func->otype==oclass->type; func=func->next)
                count += fprintf(fp, "\t\t<function>%s</function>\n", func->name);
            for (prop=oclass->pmap; prop!=NULL && prop->otype==oclass->type; prop=prop->next)
            {
                char *propname = class_get_property_typename(prop->ptype);
                if (propname!=NULL)
                    count += fprintf(fp,"\t\t\t<property type=\"%s\">%s</property>\n", propname, prop->name);
            }
            count += fprintf(fp,"\t\t</class>\n");
        }
    }
    count += fprintf(fp,"\t</classes>\n");
    return count;
}

void class_profiles(void)
{
    CLASS *cl;
    int64 total=0;
    int count=0, i=0, hits;
    CLASS **index;
    output_profile("Model profiler results");
    output_profile("======================\n");
    output_profile("Class            Time (s) Time (%%) msec/obj");
    output_profile("---------------- -------- -------- --------");
    for (cl=first_class; cl!=NULL; cl=cl->next)
    {
        total+=cl->profiler.clocks;
        count++;
    }
    index = (CLASS**)malloc(sizeof(CLASS*)*count);
    for (cl=first_class; cl!=NULL; cl=cl->next)
        index[i++]=cl;
    hits=-1;
    while (hits!=0)
    {
        hits=0;
        for (i=0; i<count-1; i++)
        {
            if (index[i]->profiler.clocks<index[i+1]->profiler.clocks)
            {
                CLASS *tmp = index[i];
                index[i]=index[i+1];
                index[i+1]=tmp;
                hits++;
            }
        }
    }
    for (i=0; i<count; i++)
    {
        cl = index[i];
        if (cl->profiler.clocks>0)
        {
            double ts = (double)cl->profiler.clocks/CLOCKS_PER_SEC;
            double tp = (double)cl->profiler.clocks/total*100;
            double mt = ts/cl->profiler.numobjs*1000;
            output_profile("%-16.16s %7.3f %8.1f%% %8.1f", cl->name, ts,tp,mt);
        }
        else
            break;
    }
    free(index);
    output_profile("================ ======== ======== ========");
    output_profile("%-16.16s %7.3f %8.1f%% %8.1f\n", 
        "Total", (double)total/CLOCKS_PER_SEC,100.0,1000*(double)total/CLOCKS_PER_SEC/object_get_count());

}

DELEGATEDTYPE *class_register_type(CLASS *oclass, 
                                   char *type, 
                                   int (*from_string)(void*,char*), 
                                   int (*to_string)(void*,char*,int)) 
{
    DELEGATEDTYPE *dt = (DELEGATEDTYPE*)malloc(sizeof(DELEGATEDTYPE));
    if (dt!=NULL)
    {
        dt->oclass = oclass;
        strncpy(dt->type,type,sizeof(dt->type));
        dt->from_string = from_string;
        dt->to_string = to_string;
    }
    else
        output_error("unable to register delegated type (memory allocation failed)");
    return dt;
}

/* this is not supported */
int class_define_type(CLASS *oclass, DELEGATEDTYPE *delegation, ...)
{
    output_error("delegated types not supported using class_define_type (use class_define_map instead)");
    return 0;
}

static int check = 0;  /* there must be a better way to do this, but this works. -MH */

static int buffer_write(char *buffer, size_t len, char *format, ...){
    char temp[1025];
    unsigned int count = 0;
    va_list ptr;

    if(buffer == NULL)
        return 0;
    if(len < 1)
        return 0;
    if(check == 0)
        return 0;
    
    va_start(ptr,format);
    count = vsprintf(temp, format, ptr);
    va_end(ptr);

    if(count < len){
        strncpy(buffer, temp, count);
        return count;
    } else {
        check = 0;
        return 0;
    }
}

int class_get_xsd(CLASS *oclass, 
                  char *buffer, 
                  size_t len) 
{
    size_t n=0;
    PROPERTY *prop;
    int i;
    extern KEYWORD oflags[];
    struct {
        char *name;
        char *type;
        KEYWORD *keys;
    } attribute[]={
        {"id", "int64",NULL},
        {"parent", "object",NULL},
        {"rank", "int32",NULL},
        {"clock", "datetime",NULL},
        {"latitude", "latitude",NULL},
        {"longitude", "longitude",NULL},
        {"in_svc", "datetime",NULL},
        {"out_svc", "datetime",NULL},
        {"flags", "set",oflags},
    };
    check = 1;
    n += buffer_write(buffer+n, len-n, "<xs:element name=\"%s\">\n", oclass->name);
    n += buffer_write(buffer+n, len-n, "\t<xs:complexType>\n");
    n += buffer_write(buffer+n, len-n, "\t\t<xs:all>\n");
    for (i=0; i < sizeof(attribute) / sizeof(attribute[0]); i++)
    {
        n += buffer_write(buffer+n, len-n, "\t\t\t<xs:element name=\"%s\">\n", attribute[i].name);
        n += buffer_write(buffer+n, len-n, "\t\t\t\t<xs:simpleType>\n");
        if (attribute[i].keys==NULL){
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t<xs:restriction base=\"xs:%s\"/>\n", attribute[i].type);
        }
        else
        {
            KEYWORD *key;
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t<xs:restriction base=\"xs:string\">\n");
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t\t<xs:pattern value=\"");
            for (key=attribute[i].keys; key!=NULL; key=key->next){
                n += buffer_write(buffer+n, len-n, "%s%s", key==attribute[i].keys?"":"|", key->name);
            }
            n += buffer_write(buffer+n, len-n, "\"/>\n");
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t</xs:restriction>\n");
        }
        n += buffer_write(buffer+n, len-n, "\t\t\t\t</xs:simpleType>\n");
        n += buffer_write(buffer+n, len-n, "\t\t\t</xs:element>\n");
    }
    for (prop=oclass->pmap; prop!=NULL && prop->otype==oclass->type; prop=prop->next)
    {
        char *proptype=class_get_property_typename(prop->ptype);
        if (prop->unit!=NULL){
            n += buffer_write(buffer+n, len-n, "\t\t\t\t<xs:element name=\"%s\" type=\"xs:string\"/>\n", prop->name);
        } else {
            n += buffer_write(buffer+n, len-n, "\t\t\t<xs:element name=\"%s\">\n", prop->name);
            n += buffer_write(buffer+n, len-n, "\t\t\t\t<xs:simpleType>\n");
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t<xs:restriction base=\"xs:%s\">\n", proptype==NULL?"string":proptype);
            if (prop->keywords!=NULL)
            {
                KEYWORD *key;
                n += buffer_write(buffer+n, len-n, "\t\t\t\t\t<xs:pattern value=\"");
                for (key=prop->keywords; key!=NULL; key=key->next){
                    n += buffer_write(buffer+n, len-n, "%s%s", key==prop->keywords?"":"|", key->name);
                }
                n += buffer_write(buffer+n, len-n, "\"/>\n"); 
            }
            n += buffer_write(buffer+n, len-n, "\t\t\t\t\t</xs:restriction>\n");
            n += buffer_write(buffer+n, len-n, "\t\t\t\t</xs:simpleType>\n");
            n += buffer_write(buffer+n, len-n, "\t\t\t</xs:element>\n");
        }
    }
    n += buffer_write(buffer+n, len-n, "\t\t</xs:all>\n");
    n += buffer_write(buffer+n, len-n, "\t</xs:complexType>\n");
    n += buffer_write(buffer+n, len-n, "</xs:element>\n");
    buffer[n] = 0;
    if(check == 0){
        printf("class_get_xsd() overflowed.\n");
        buffer[0] = 0;
        return 0;
    }
    return (int)n;
}

---

GridLAB-D^TM Version 1.0

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