core/gridlabd.h

#ifndef _GRIDLABD_H
#define _GRIDLABD_H

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#ifdef WIN32
#define HAVE_LIBCPPUNIT
#endif

#ifdef __cplusplus
    #ifndef CDECL
        #define CDECL extern "C"
    #endif
#else
    #define CDECL
#endif

#ifdef WIN32
#ifndef EXPORT
#define EXPORT CDECL __declspec(dllexport)
#endif
#else
#define EXPORT CDECL
#endif

#include "schedule.h"
#include "object.h"
#include "find.h"
#include "random.h"

#ifdef DLMAIN
#define EXTERN
#define INIT(X) =(X)
#else
#ifdef __cplusplus
#define EXTERN
#else
#define EXTERN extern
#endif /* __cplusplus */
#define INIT(X)
#endif
CDECL EXPORT EXTERN CALLBACKS *callback INIT(NULL);
#undef INIT
#undef EXTERN

#ifndef MODULENAME
#define MODULENAME(obj) (obj->oclass->module->name)
#endif

/******************************************************************************
 * Variable publishing
 */
#define PUBLISH_STRUCT(C,T,N) {struct C _t;if (gl_publish_variable(C##_class,PT_##T,#N,(char*)&_t.N-(char*)&_t,NULL)<1) return NULL;}

#define PUBLISH_CLASS(C,T,N) {class C _t;if (gl_publish_variable(C##_class,PT_##T,#N,(char*)&_t.N-(char*)&_t,NULL)<1) return NULL;}

#define PUBLISH_CLASSX(C,T,N,V) {class C _t;if (gl_publish_variable(C##_class,PT_##T,V,(char*)&_t.N-(char*)&_t,NULL)<1) return NULL;}

//#define PUBLISH_CLASS_UNIT(C,T,N,U) {class C _t;if (gl_publish_variable(C##_class,PT_##T,#N"["U"]",(char*)&_t.N-(char*)&_t,NULL)<1) return NULL;}
#define PUBLISH_DELEGATED(C,T,N) {class C _t;if (gl_publish_variable(C##_class,PT_delegated,T,#N,(char*)&_t.N-(char*)&_t,NULL)<1) return NULL;}

//#define PUBLISH_ENUM(C,N,E) (*callback->define_enumeration_member)(C##_class,#N,#E,C::E)

//#define PUBLISH_SET(C,N,E) (*callback->define_set_member)(C##_class,#N,#E,C::E)
#define PADDR(X) ((char*)&(this->X)-(char*)this)

/******************************************************************************
 * Exception handling
 */
#define GL_TRY { EXCEPTIONHANDLER *_handler = (*callback->exception.create_exception_handler)(); if (_handler==NULL) (*callback->output_error)("%s(%d): module exception handler creation failed",__FILE__,__LINE__); else if (setjmp(_handler->buf)==0) {
/* TROUBLESHOOT
    This error is caused when the system is unable to implement an exception handler for a module.
    This is an internal error and should be reported to the module developer.
 */
#define GL_THROW (*callback->exception.throw_exception)

#define GL_CATCH(Msg) } else {Msg = (*callback->exception.exception_msg)();

#define GL_ENDCATCH } (*callback->exception.delete_exception_handler)(_handler);}

/******************************************************************************
 * Output functions
 */
#define gl_verbose (*callback->output_verbose)

#define gl_output (*callback->output_message)

#define gl_warning (*callback->output_warning)

#define gl_error (*callback->output_error)

#ifdef _DEBUG

#define gl_debug (*callback->output_debug)
#else
#define gl_debug
#endif

#define gl_testmsg (*callback->output_test)

/******************************************************************************
 * Memory allocation
 */
#define gl_malloc (*callback->malloc)

/******************************************************************************
 * Core access
 */
#define set_callback(CT) (callback=(CT))

#define gl_get_module_var (*callback->get_module_var)

#define gl_findfile (*callback->file.find_file)

#define gl_find_module (*callback->module_find)

#define gl_find_property (*callback->find_property)

#ifdef __cplusplus
inline int gl_module_depends(char *name, 
                             unsigned char major=0, 
                             unsigned char minor=0, 
                             unsigned short build=0) 
{
    return (*callback->depends)(name,major,minor,build);
}
#else
#define gl_module_depends (*callback->depends)
#endif


/******************************************************************************
 * Class registration
 */
#define gl_register_class (*callback->register_class)

/******************************************************************************
 * Object management
 */
#define gl_create_object (*callback->create.single)

#define gl_create_array (*callback->create.array)

#define gl_create_foreign (*callback->create.foreign)

#ifdef __cplusplus
inline bool gl_object_isa(OBJECT *obj, 
                          char *type,
                          char *modname=NULL) 
{   bool rv = (*callback->object_isa)(obj,type)!=0;
    bool mv = modname ? obj->oclass->module == (*callback->module_find)(modname) : true;
    return (rv && mv);}
#else
#define gl_object_isa (*callback->object_isa)
#endif

#define gl_publish_variable (*callback->define_map)

#ifdef __cplusplus
inline FUNCTION *gl_publish_function(CLASS *oclass, 
                                     FUNCTIONNAME functionname, 
                                     FUNCTIONADDR call) 
{ return (*callback->function.define)(oclass, functionname, call);}
inline FUNCTIONADDR gl_get_function(OBJECT *obj, char *name)
{ return obj?(*callback->function.get)(obj->oclass->name,name):NULL;}
#else
#define gl_publish_function (*callback->function.define)
#define gl_get_function (*callback->function.get)
#endif

#ifdef __cplusplus
inline int gl_set_dependent(OBJECT *obj, 
                            OBJECT *dep) 
{ return (*callback->set_dependent)(obj,dep);}
#else
#define gl_set_dependent (*callback->set_dependent)
#endif

#ifdef __cplusplus
inline int gl_set_parent(OBJECT *obj, 
                         OBJECT *parent) 
{ return (*callback->set_parent)(obj,parent);}
#else
#define gl_set_parent (*callback->set_parent)
#endif

#ifdef __cplusplus
inline int gl_set_rank(OBJECT *obj, 
                       int rank)    
{ return (*callback->set_rank)(obj,rank);}
#else
#define gl_set_rank (*callback->set_rank)
#endif

/******************************************************************************
 * Property management
 */
#define gl_register_type (*callback->register_type)

#define gl_publish_delegate (*callback->define_type)

#ifdef __cplusplus
inline PROPERTY *gl_get_property(OBJECT *obj, 
                                 PROPERTYNAME name) 
{ return (*callback->properties.get_property)(obj,name); }
#else
#define gl_get_property (*callback->properties.get_property)
#endif

#ifdef __cplusplus
inline int gl_get_value(OBJECT *obj, 
                        void *addr, 
                        char *value, 
                        int size, 
                        PROPERTY *prop=NULL) 
{ return (*callback->properties.get_value_by_addr)(obj,addr,value,size,prop);}
#else
#define gl_get_value (*callback->properties.get_value_by_addr)
#endif
#define gl_set_value_by_type (*callback->properties.set_value_by_type)

#ifdef __cplusplus
inline int gl_set_value(OBJECT *obj, 
                        void *addr, 
                        char *value, 
                        PROPERTY *prop) 
{ return (*callback->properties.set_value_by_addr)(obj,addr,value,prop);}
#else
#define gl_set_value (*callback->properties.set_value_by_addr)
#endif

#ifdef __cplusplus
/* 'stolen' from rt/gridlabd.h, something dchassin squirreled in. -mhauer */
template <class T> inline int gl_set_value(OBJECT *obj, 
                                            PROPERTY *prop, 
                                            T &value) 
{
    //T *ptr = (T*)gl_get_addr(obj,propname);
    char buffer[256];
    T *ptr = (T *)((char *)(obj + 1) + (int64)(prop->addr)); /* warning: cast from pointer to integer of different size */
    // @todo it would be a good idea to check the property type here
    if (ptr==NULL)
        GL_THROW("property %s not found in object %s", prop->name, gl_name(obj, buffer, 255));
    if(obj->oclass->notify){
        if(obj->oclass->notify(obj,NM_PREUPDATE,prop) == 0){
            gl_error("preupdate notify failure on %s in %s", prop->name, obj->name ? obj->name : "an unnamed object");
        }
    }
    *ptr = value;
    if(obj->oclass->notify){
        if(obj->oclass->notify(obj,NM_POSTUPDATE,prop) == 0){
            gl_error("postupdate notify failure on %s in %s", prop->name, obj->name ? obj->name : "an unnamed object");
        }
    }
    return 1;
}
#endif

#define gl_get_reference (*callback->properties.get_reference)

#ifdef __cplusplus
inline int gl_get_value_by_name(OBJECT *obj,
                                PROPERTYNAME name,
                                char *value,
                                int size)
{ return (*callback->properties.get_value_by_name)(obj,name,value,size);}
#else
#define gl_get_value_by_name (*callback->properties.get_value_by_name)
#endif

#ifdef __cplusplus
inline char *gl_getvalue(OBJECT *obj,
                         PROPERTYNAME name)
{
    static char buffer[1024];
    memset(buffer,0,sizeof(buffer));
    return gl_get_value_by_name(obj,name,buffer,sizeof(buffer))>=0 ? buffer : NULL;
}
#endif

#define gl_set_value_by_name (*callback->properties.set_value_by_name)

#define gl_get_unit (*callback->properties.get_unit)

#define gl_convert (*callback->unit_convert)

#define gl_convert_ex (*callback->unit_convert_ex)

#define gl_find_unit (*callback->unit_find)

#define gl_get_object (*callback->get_object)

#define gl_name_object (*callback->name_object)

#define gl_get_object_count (*callback->object_count)

#define gl_get_object_prop (*callback->objvar.object_var)

#define gl_get_complex (*callback->objvar.complex_var)

#define gl_get_complex_by_name (*callback->objvarname.complex_var)

#define gl_get_enum (*callback->objvar.enum_var)

#define gl_get_enum_by_name (*callback->objvarname.enum_var)

#define gl_get_int16 (*callback->objvar.int16_var)

#define gl_get_int16_by_name (*callback->objvarname.int16_var)

#define gl_get_int32_by_name (*callback->objvarname.int32_var)

#define gl_get_int32 (*callback->objvar.int32_var)

#define gl_get_int64_by_name (*callback->objvarname.int64_var)

#define gl_get_int64 (*callback->objvar.int64_var)

#define gl_get_double_by_name (*callback->objvarname.double_var)

#define gl_get_double (*callback->objvar.double_var)

#define gl_get_string_by_name (*callback->objvarname.string_var)

#define gl_get_string (*callback->objvar.string_var)

#define gl_get_addr (*callback->properties.get_addr)

/******************************************************************************
 * Object search
 */
#define gl_find_objects (*callback->find.objects)

#define gl_find_next (*callback->find.next)

#define gl_findlist_copy (*callback->find.copy)
#define gl_findlist_add (*callback->find.add)
#define gl_findlist_del (*callback->find.del)
#define gl_findlist_clear (*callback->find.clear)

#define gl_free (*callback->free)

#define gl_create_aggregate (*callback->create_aggregate)

#define gl_run_aggregate (*callback->run_aggregate)

/******************************************************************************
 * Random number generation
 */
#define gl_randomtype (*callback->random.type)

#define gl_randomvalue (*callback->random.value)

#define gl_pseudorandomvalue (*callback->random.pseudo)

#define gl_random_uniform (*callback->random.uniform)

#define gl_random_normal (*callback->random.normal)

#define gl_random_lognormal (*callback->random.lognormal)

#define gl_random_bernoulli (*callback->random.bernoulli)

#define gl_random_pareto (*callback->random.pareto)

#define gl_random_sampled (*callback->random.sampled)

#define gl_random_exponential (*callback->random.exponential)
#define gl_random_triangle (*callback->random.triangle)
#define gl_random_gamma (*callback->random.gamma)
#define gl_random_beta (*callback->random.beta)
#define gl_random_weibull (*callback->random.weibull)
#define gl_random_rayleigh (*callback->random.rayleigh)

/******************************************************************************
 * Timestamp handling
 */
#define gl_globalclock (*(callback->global_clock))

#define gl_parsetime (*callback->time.convert_to_timestamp)

#define gl_printtime (*callback->time.convert_from_timestamp)

#define gl_mktime (*callback->time.mkdatetime)

#define gl_strtime (*callback->time.strdatetime)

#define gl_todays (*callback->time.timestamp_to_days)

#define gl_tohours (*callback->time.timestamp_to_hours)

#define gl_tominutes (*callback->time.timestamp_to_minutes)

#define gl_toseconds (*callback->time.timestamp_to_seconds)

#define gl_localtime (*callback->time.local_datetime)

#ifdef __cplusplus
inline int gl_getweekday(TIMESTAMP t)
{
    DATETIME dt;
    gl_localtime(t, &dt);
    return dt.weekday;
}
inline int gl_gethour(TIMESTAMP t)
{
    DATETIME dt;
    gl_localtime(t, &dt);
    return dt.hour;
}
#endif

/******************************************************************************
 * Global variables
 */
#define gl_global_create (*callback->global.create)

#define gl_global_setvar (*callback->global.setvar)

#define gl_global_getvar (*callback->global.getvar)

#define gl_global_find (*callback->global.find)

#define gl_get_oflags (*callback->get_oflags)

#ifdef __cplusplus

inline double clip(double x, 
                   double a, 
                   double b) 
{
    if (x<a) return a;
    else if (x>b) return b;
    else return x;
}

inline char bitof(unsigned int64 x,
                           bool use_throw=false) 
{
    char n=0;
    if (x==0)
    {
        if (use_throw)
            throw "bitof empty bit pattern";
        return -0x7f;
    }
    while ((x&1)==0)
    {
        x>>=1;
        n++;
    }
    if (x!=0)
    {
        if (use_throw)
            throw "bitof found more than one bit";
        else
            return -n;
    }
    return n;
}
inline char* gl_name(OBJECT *my, char *buffer, size_t size)
{
    char temp[256];
    if(my == NULL || buffer == NULL) return NULL;
    if (my->name==NULL)
        sprintf(temp,"%s:%d", my->oclass->name, my->id);
    else
        sprintf(temp,"%s", my->name);
    if(size < strlen(temp))
        return NULL;
    strcpy(buffer, temp);
    return buffer;
}

inline SCHEDULE *gl_schedule_find(char *name)
{
    return callback->schedule.find(name);
}

inline SCHEDULE *gl_schedule_create(char *name, char *definition)
{
    return callback->schedule.create(name,definition);
}

inline SCHEDULEINDEX gl_schedule_index(SCHEDULE *sch, TIMESTAMP ts)
{
    return callback->schedule.index(sch,ts);
}

inline double gl_schedule_value(SCHEDULE *sch, SCHEDULEINDEX index)
{
    return callback->schedule.value(sch,index);
}

inline long gl_schedule_dtnext(SCHEDULE *sch, SCHEDULEINDEX index)
{
    return callback->schedule.dtnext(sch,index);
}

inline int gl_enduse_create(enduse *e)
{
    return callback->enduse.create(e);
}

inline TIMESTAMP gl_enduse_sync(enduse *e, TIMESTAMP t1)
{
    return callback->enduse.sync(e,PC_BOTTOMUP,t1);
}

inline loadshape *gl_loadshape_create(SCHEDULE *s)
{
    loadshape *ls = (loadshape*)malloc(sizeof(loadshape));
    memset(ls,0,sizeof(loadshape));
    if (0 == callback->loadshape.create(ls)){
        return NULL;
    }
    ls->schedule = s;
    return ls;
}

inline double gl_get_loadshape_value(loadshape *shape)
{
    if (shape)
        return shape->load;
    else
        return 0;
}

inline char *gl_strftime(DATETIME *dt, char *buffer, int size) { return callback->time.strdatetime(dt,buffer,size)?buffer:NULL;};
inline char *gl_strftime(TIMESTAMP ts)
{
    static char buffer[64];
    strcpy(buffer,"(invalid time)");
    DATETIME dt;
    if(gl_localtime(ts,&dt)){
        gl_strftime(&dt,buffer,sizeof(buffer));
    }
    return buffer;
}
#endif //__cplusplus


/******************************************************************************
 * Interpolation routines
 */
#define gl_lerp (*callback->interpolate.linear)

#define gl_qerp (*callback->interpolate.quadratic)

#endif

---

GridLAB-D^TM Version 2.0

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