core/object.h

Go to the documentation of this file.

#ifndef _OBJECT_H
#define _OBJECT_H

#include "complex.h"
#include "timestamp.h"
#include "class.h"
#include "aggregate.h"
#include "exception.h"
#include "globals.h"
#include "random.h"

/* this must match property_type list in object.c */
typedef unsigned int OBJECTRANK; 
typedef unsigned short OBJECTSIZE; 
typedef unsigned int OBJECTNUM; 
typedef char * OBJECTNAME; 
/* object flags */
#define OF_NONE   0x0000 
#define OF_HASPLC 0x0001 
#define OF_LOCKED 0x0002 
#define OF_RECALC 0x0008 
#define OF_RERANK 0x4000 
typedef struct s_object_list {
    OBJECTSIZE size; 
    OBJECTNUM id; 
    CLASS *oclass; 
    struct s_object_list *next; 
    struct s_object_list *parent; 
    OBJECTRANK rank; 
    TIMESTAMP clock; 
    double latitude, longitude; 
    TIMESTAMP in_svc, 
        out_svc; 
    OBJECTNAME name;
    unsigned long flags; 
    /* IMPORTANT: flags must be last */
} OBJECT; 
/* this is the callback table for modules
 * the table is initialized in module.cpp
 */
typedef struct s_callbacks {
    TIMESTAMP *global_clock;
    int (*output_verbose)(char *format, ...);
    int (*output_message)(char *format, ...);
    int (*output_warning)(char *format, ...);
    int (*output_error)(char *format, ...);
    int (*output_debug)(char *format, ...);
    int (*output_test)(char *format, ...);
    CLASS *(*register_class)(MODULE *,CLASSNAME,PASSCONFIG);
    OBJECT *(*create_single)(CLASS*,OBJECTSIZE);
    OBJECT *(*create_array)(CLASS*,OBJECTSIZE,unsigned int);
    int (*define_map)(CLASS*,...);
    FUNCTION *(*define_function)(CLASS*,FUNCTIONNAME,FUNCTIONADDR);
    int (*define_enumeration_member)(CLASS*,char*,char*,enumeration);
    int (*define_set_member)(CLASS*,char*,char*,unsigned long);
    int (*set_dependent)(OBJECT*,OBJECT*);
    int (*set_parent)(OBJECT*,OBJECT*);
    int (*set_rank)(OBJECT*,unsigned int);
    struct {
        PROPERTY *(*get_property)(OBJECT*,PROPERTYNAME);
        int (*set_value_by_addr)(OBJECT *, void*, char*,PROPERTY*);
        int (*get_value_by_addr)(OBJECT *, void*, char*, int size,PROPERTY*);
        int (*set_value_by_name)(OBJECT *, char*, char*);
        int (*get_value_by_name)(OBJECT *, char*, char*, int size);
    } properties;
    struct s_findlist *(*find_objects)(struct s_findlist *,...);
    OBJECT *(*find_next)(struct s_findlist *,OBJECT *obj);
    void *(*malloc)(size_t);
    void (*free)(void*);
    struct s_aggregate *(*create_aggregate)(char *aggregator, char *group_expression);
    //struct s_aggregate *(*create_aggregate_zwei)(char *aggregator, struct s_aggregate *aggr);
    double (*run_aggregate)(struct s_aggregate *aggregate);
    double *(*get_module_var)(MODULE *module_name, char *varname);
    struct {
        double (*uniform)(double a, double b);
        double (*normal)(double m, double s);
        double (*bernoulli)(double p);
        double (*pareto)(double m, double a);
        double (*lognormal)(double m, double s);
        double (*sampled)(unsigned int n, double *x);
        double (*exponential)(double l);
        RANDOMTYPE (*type)(char *name);
        double (*value)(RANDOMTYPE type, ...);
    } random;
    int (*object_isa)(OBJECT *obj, char *type);
    DELEGATEDTYPE* (*register_type)(CLASS *oclass, char *type,int (*from_string)(void*,char*),int (*to_string)(void*,char*,int));
    int (*define_type)(CLASS*,DELEGATEDTYPE*,...);
    struct {
        TIMESTAMP (*mkdatetime)(DATETIME *dt);
        int (*strdatetime)(DATETIME *t, char *buffer, int size);
        double (*timestamp_to_days)(TIMESTAMP t);
        double (*timestamp_to_hours)(TIMESTAMP t);
        double (*timestamp_to_minutes)(TIMESTAMP t);
        double (*timestamp_to_seconds)(TIMESTAMP t);
        int (*local_datetime)(TIMESTAMP ts, DATETIME *dt);
        TIMESTAMP (*convert_to_timestamp)(char *value);
    } time;
    int (*unit_convert)(char *from, char *to, double *value);
    int (*unit_convert_ex)(UNIT *pFrom, UNIT *pTo, double *pValue);
    struct {
        EXCEPTIONHANDLER *(*create_exception_handler)();
        void (*delete_exception_handler)(EXCEPTIONHANDLER *ptr);
        void (*throw_exception)(char *msg, ...);
        char *(*exception_msg)(void);
    } exception;
    struct {
        GLOBALVAR *(*create)(char *name, ...);
        STATUS (*setvar)(char *def,...);
        char *(*getvar)(char *name, char *buffer, int size);
        GLOBALVAR *(*find)(char *name);
    } global;
#ifndef NOLOCKS
    int64 *lock_count, *lock_spin;
#endif
    struct {
        char *(*find_file)(char *name, char *path, int mode);
    } file;
    struct s_objvar_struct {
        complex *(*complex_var)(OBJECT *obj, PROPERTY *prop);
        int16 *(*int16_var)(OBJECT *obj, PROPERTY *prop);
        int32 *(*int32_var)(OBJECT *obj, PROPERTY *prop);
        int64 *(*int64_var)(OBJECT *obj, PROPERTY *prop);
        double *(*double_var)(OBJECT *obj, PROPERTY *prop);
        char *(*string_var)(OBJECT *obj, PROPERTY *prop);
        OBJECT *(*object_var)(OBJECT *obj, PROPERTY *prop);
    } objvar;
    struct s_objvar_name_struct {
        complex *(*complex_var)(OBJECT *obj, char *name);
        int16 *(*int16_var)(OBJECT *obj, char *name);
        int32 *(*int32_var)(OBJECT *obj, char *name);
        int64 *(*int64_var)(OBJECT *obj, char *name);
        double *(*double_var)(OBJECT *obj, char *name);
        char *(*string_var)(OBJECT *obj, char *name);
    } objvarname;
    struct {
        int (*string_to_property)(PROPERTY *prop, void *addr, char *value);
        int (*property_to_string)(PROPERTY *prop, void *addr, char *value, int size);
    } convert;
    MODULE *(*module_find)(char *name);
    OBJECT *(*get_object)(char *name);
    int (*get_oflags)(KEYWORD **extflags);
} CALLBACKS; 
#ifdef __cplusplus
extern "C" {
#endif

OBJECT *object_create_single(CLASS *oclass, OBJECTSIZE size);
OBJECT *object_create_array(CLASS *oclass, OBJECTSIZE size, unsigned int n_objects);
OBJECT *object_remove_by_id(OBJECTNUM id);
int object_init(OBJECT *obj);
int object_set_dependent(OBJECT *obj, OBJECT *dependent);
int object_set_parent(OBJECT *obj, OBJECT *parent);
void *object_get_addr(OBJECT *obj, char *name);
PROPERTY *object_get_property(OBJECT *obj, PROPERTYNAME name);
int object_set_value_by_name(OBJECT *obj, PROPERTYNAME name, char *value);
int object_set_value_by_addr(OBJECT *obj, void *addr, char *value, PROPERTY *prop);
int object_set_double_by_name(OBJECT *obj, PROPERTYNAME name, double value);
int object_get_value_by_name(OBJECT *obj, PROPERTYNAME name, char *value, int size);
int object_get_value_by_addr(OBJECT *obj, void *addr, char *value, int size, PROPERTY *prop);
int object_isa(OBJECT *obj, char *type);
void object_set_name(OBJECT *obj, OBJECTNAME name);
OBJECT *object_find_name(OBJECTNAME name);

int object_get_oflags(KEYWORD **extflags);

TIMESTAMP object_sync(OBJECT *obj, TIMESTAMP to,PASSCONFIG pass);
PROPERTY *object_get_property(OBJECT *obj, PROPERTYNAME name);
OBJECT *object_get_object(OBJECT *obj, PROPERTY *prop);
int16 *object_get_int16(OBJECT *obj, PROPERTY *prop);
int16 *object_get_int16_by_name(OBJECT *obj, char *name);
int32 *object_get_int32(OBJECT *obj, PROPERTY *prop);
int32 *object_get_int32_by_name(OBJECT *obj, char *name);
int64 *object_get_int64(OBJECT *obj, PROPERTY *prop);
int64 *object_get_int64_by_name(OBJECT *obj, char *name);
double *object_get_double(OBJECT *pObj, PROPERTY *prop);
double *object_get_double_by_name(OBJECT *pObj, char *name);
complex *object_get_complex(OBJECT *pObj, PROPERTY *prop);
complex *object_get_complex_by_name(OBJECT *pObj, char *name);
double *object_get_double_quick(OBJECT *pObj, PROPERTY *prop);
complex *object_get_complex_quick(OBJECT *pObj, PROPERTY *prop);
char *object_get_string(OBJECT *pObj, PROPERTY *prop);
char *object_get_string_by_name(OBJECT *obj, char *name);
FUNCTIONADDR object_get_function(CLASSNAME classname, FUNCTIONNAME functionname);
char *object_property_to_string(OBJECT *obj, char *name);
int object_set_rank(OBJECT *obj, OBJECTRANK rank);

OBJECT *object_find_by_id(OBJECTNUM id);
OBJECT *object_get_first();
OBJECT *object_get_next(OBJECT *obj);
unsigned int object_get_count(void);
int object_dump(char *buffer, int size, OBJECT *obj);
int object_saveall(FILE *fp);
int object_saveall_xml(FILE *fp);

char *object_name(OBJECT *obj);
int convert_from_latitude(double,void*,int);
int convert_from_longitude(double,void*,int);
double convert_to_latitude(char *buffer);
double convert_to_longitude(char *buffer);

PROPERTY *object_flag_property(void);

#ifdef __cplusplus
}
#endif


#define object_size(X) ((X)?(X)->size:-1) 
#define object_id(X) ((X)?(X)->id:-1) 
#define object_parent(X) ((X)?(X)->parent:NULL) 
#define object_rank(X) ((X)?(X)->name:-1) 
#define OBJECTDATA(X,T) ((T*)((X)?((X)+1):NULL)) 
#define GETADDR(O,P) (O?((void*)((char*)(O+1)+(unsigned int64)((P)->addr))):NULL) 
#define OBJECTHDR(X) ((X)?(((OBJECT*)X)-1):NULL) 
#define MYPARENT ((((OBJECT*)this)-1)->parent) 
#endif

---

GridLAB-D^TM Version 1.0

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