core/gridlabd.h

Go to the documentation of this file.

#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 "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

/******************************************************************************
 * 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): exception handler creation failed",__FILE__,__LINE__); else if (setjmp(_handler->buf)==0) {

#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)

#define gl_debug (*callback->output_debug)

#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)

/******************************************************************************
 * 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)

#ifdef __cplusplus
inline bool gl_object_isa(OBJECT *obj, 
                          char *type) 
{ return (*callback->object_isa)(obj,type)!=0;}
#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->define_function)(oclass, functionname, call);}
#else
#define gl_publish_function (*callback->define_function)
#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

#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

#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

#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_get_object (*callback->get_object)

#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_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)

/******************************************************************************
 * Object search
 */
#define gl_find_objects (*callback->find_objects)

#define gl_find_next (*callback->find_next)

#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_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)

/******************************************************************************
 * Timestamp handling
 */
#define gl_parsetime (*callback->time.convert_to_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)

/******************************************************************************
 * 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;
}
#endif


#endif

---

GridLAB-D^TM Version 1.0

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