core/class.h

Go to the documentation of this file.

#ifndef _CLASS_H
#define _CLASS_H

#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <time.h>

#include "platform.h"
#include "complex.h"
#include "unit.h"

typedef struct s_class_list CLASS;

/* Valid GridLAB data types */
typedef char char1024[1025]; 
typedef char char256[257]; 
typedef char char32[33]; 
typedef char char8[9]; 
typedef char int8; 
typedef short int16; 
typedef int int32; /* 32-bit integers */
typedef long enumeration; /* enumerations (any one of a list of values) */
typedef struct s_object_list* object; /* GridLAB objects */
typedef unsigned int64 set; /* sets (each of up to 64 values may be defined) */
typedef double triplet[3];
typedef complex triplex[3];
#ifdef REAL4
typedef float real; 
#else
typedef double real;
#endif

#ifndef __cplusplus
#ifndef true
typedef unsigned char bool;
#define true (1)
#define false (0)
#endif
#endif


/* delegated types allow module to keep all type operations private
 * this includes convert operations and allocation/deallocation
 */
typedef struct s_delegatedtype
{
    char32 type; 
    CLASS *oclass; 
    int (*from_string)(void *addr, char *value); 
    int (*to_string)(void *addr, char *value, int size); 
} DELEGATEDTYPE; 
typedef struct s_delegatedvalue
{
    char *data; 
    DELEGATEDTYPE *type; 
} DELEGATEDVALUE; 
typedef DELEGATEDVALUE* delegated; /* delegated data type */

/* int64 is already defined in platform.h */
typedef enum {_PT_FIRST=-1, 
    PT_void, 
    PT_double, 
    PT_complex, 
    PT_enumeration, 
    PT_set, 
    PT_int16, 
    PT_int32, 
    PT_int64, 
    PT_char8, 
    PT_char32, 
    PT_char256, 
    PT_char1024, 
    PT_object, 
    PT_delegated, 
    PT_bool, 
    PT_timestamp, 
    PT_double_array, 
    PT_complex_array, 
/*  PT_object_array, */ 
    PT_float,   
    PT_real,    
    PT_loadshape,   
    PT_enduse,      
#ifdef USE_TRIPLETS
    PT_triple, 
    PT_triplex, 
#endif
    _PT_LAST, 
    /* never put these before _PT_LAST they have special uses */
    PT_AGGREGATE, /* internal use only */
    PT_KEYWORD, /* used to add an enum/set keyword definition */
    PT_ACCESS, /* used to specify property access rights */
    PT_SIZE, /* used to setup arrayed properties */
    PT_FLAGS, /* used to indicate property flags next */
    PT_INHERIT, /* used to indicate that properties from a parent class are to be published */
    PT_UNITS, /* used to indicate that property has certain units (which following immediately as a string) */
    PT_DESCRIPTION, /* used to provide helpful description of property */
    PT_EXTEND, /* used to enlarge class size by the size of the current property being mapped */
    PT_EXTENDBY, /* used to enlarge class size by the size provided in the next argument */
    PT_DEPRECATED, /* used to flag a property that is deprecated */
} PROPERTYTYPE; 
typedef char CLASSNAME[64]; 
typedef void* PROPERTYADDR; 
typedef char PROPERTYNAME[64]; 
typedef char FUNCTIONNAME[64]; 
typedef enum {
    PA_PUBLIC, 
    PA_REFERENCE, 
    PA_PROTECTED, 
    PA_PRIVATE, 
} PROPERTYACCESS; 
typedef int64 (*FUNCTIONADDR)(void*,...); 
/* pass configuration */
typedef unsigned char PASSCONFIG; 
#define PC_NOSYNC 0x00                  
#define PC_PRETOPDOWN 0x01              
#define PC_BOTTOMUP 0x02                
#define PC_POSTTOPDOWN 0x04             
#define PC_FORCE_NAME 0x20              
#define PC_PARENT_OVERRIDE_OMIT 0x40    
#define PC_UNSAFE_OVERRIDE_OMIT 0x80    
typedef enum {
    NM_PREUPDATE = 0, 
    NM_POSTUPDATE = 1, 
    NM_RESET = 2,
} NOTIFYMODULE; 
typedef struct s_keyword {
    char name[32];
    unsigned int64 value;
    struct s_keyword *next;
} KEYWORD;

typedef unsigned long PROPERTYFLAGS;
#define PF_RECALC   0x0001 
#define PF_CHARSET  0x0002 
#define PT_EXTENDED 0x0004 
#define PF_DEPRECATED 0x8000 
#define PF_DEPRECATED_NONOTICE 0x04000 
typedef struct s_property_map {
    CLASS *oclass; 
    PROPERTYNAME name; 
    PROPERTYTYPE ptype; 
    unsigned long size; 
    PROPERTYACCESS access; 
    UNIT *unit; 
    PROPERTYADDR addr; 
    DELEGATEDTYPE *delegation; 
    KEYWORD *keywords; 
    char *description; 
    struct s_property_map *next; 
    PROPERTYFLAGS flags; 
} PROPERTY; 
typedef struct s_function_map {
    CLASS *oclass;
    FUNCTIONNAME name;
    FUNCTIONADDR addr;
    struct s_function_map *next;
} FUNCTION;

/* Set operations */
#define SET_MASK 0xffff
#define SET_ADD(set,value) (set = set | value )
#define SET_DEL(set,value) (set = (value^SET_MASK)&set) /*SET_HAS(set,value)?set^value:set) */
#define SET_CLEAR(set) (set = 0)
#define SET_HAS(set,value) (set & value)

typedef enum {CLASSVALID=0xc44d822e} CLASSMAGIC; /* this is used to uniquely identify classes */

#define _MODULE_DEFINED_
typedef struct s_module_list MODULE;
struct s_class_list {
    CLASSMAGIC magic;
    CLASSNAME name;
    unsigned int size;
    MODULE *module; 
    PROPERTY *pmap;
    FUNCTION *fmap;
    FUNCTIONADDR create;
    FUNCTIONADDR init;
    FUNCTIONADDR sync;
    FUNCTIONADDR commit;
    FUNCTIONADDR notify;
    FUNCTIONADDR isa;
    FUNCTIONADDR plc;
    PASSCONFIG passconfig;
    FUNCTIONADDR recalc;
    CLASS *parent;          
    struct {
        int32 numobjs;
        int64 clocks;
        int32 count;
    } profiler;
    struct s_class_list *next;
}; /* CLASS */

#ifdef __cplusplus
extern "C" {
#endif

PROPERTY *class_get_first_property(CLASS *oclass);
PROPERTY *class_get_next_property(PROPERTY *prop);
PROPERTY *class_prop_in_class(CLASS *oclass, PROPERTY *prop);
PROPERTY *class_find_property(CLASS *oclass, PROPERTYNAME name);
void class_add_property(CLASS *oclass, PROPERTY *prop);
PROPERTY *class_add_extended_property(CLASS *oclass, char *name, PROPERTYTYPE ptype, char *unit);
PROPERTYTYPE class_get_propertytype_from_typename(char *name);
int class_string_to_property(PROPERTY *prop, void *addr, char *value);
int class_string_to_propertytype(PROPERTYTYPE type, void *addr, char *value);
int class_property_to_string(PROPERTY *prop, void *addr, char *value, int size);
CLASS *class_get_first_class(void);
CLASS *class_get_last_class(void);
CLASS *class_get_class_from_classname(char *name);
CLASS *class_get_class_from_classname_in_module(char *name, MODULE *mod);
char *class_get_property_typename(PROPERTYTYPE type);
int class_saveall(FILE *fp);
int class_saveall_xml(FILE *fp);
unsigned int class_get_count(void);
void class_profiles(void);
int class_get_xsd(CLASS *oclass, char *buffer, size_t len);

CLASS *class_register(MODULE *module,CLASSNAME classname,unsigned int datasize,PASSCONFIG passconfig);
int class_define_map(CLASS *oclass, ...);
int class_define_enumeration_member(CLASS *oclass,char *property_name,char *member,enumeration value);
int class_define_set_member(CLASS *oclass,char *property_name,char *member,unsigned int64 value);
FUNCTION *class_define_function(CLASS *oclass, FUNCTIONNAME functionname, FUNCTIONADDR call);
FUNCTIONADDR class_get_function(char *classname, char *functionname);
DELEGATEDTYPE *class_register_type(CLASS *oclass, char *type,int (*from_string)(void*,char*),int (*to_string)(void*,char*,int));
int class_define_type(CLASS *oclass, DELEGATEDTYPE *delegation, ...);

unsigned long property_size(PROPERTY *prop);
unsigned long property_size_by_type(PROPERTYTYPE type);
int property_create(PROPERTY *prop, void *addr);
PROPERTY *property_malloc(PROPERTYTYPE proptype, CLASS *oclass, char *name, void *addr, DELEGATEDTYPE *delegation);

#ifdef __cplusplus
}
#endif

#endif

/* EOF */

---

GridLAB-D^TM Version 2.0

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