Midas History Functions (hs_xxx)

Classes
class	MidasHistory

Macros
#define	HISTORY_PANEL(_name)

Functions
static bool	xwrite (const std::string &fn, int fh, const void *buf, size_t count)
static int	xread (const std::string &fn, int fh, void *buf, size_t count, bool eof_ok=false)
static bool	xseek (const std::string &fn, int fh, DWORD pos)
static bool	xseek_end (const std::string &fn, int fh)
static bool	xseek_cur (const std::string &fn, int fh, int offset)
static DWORD	xcurpos (const std::string &fn, int fh)
static bool	xtruncate (const std::string &fn, int fh, DWORD pos)
static INT	hs_set_path (const char *path)
static INT	hs_open_file (time_t ltime, const char *suffix, INT mode, std::string *pfile_name, int *fh)
static INT	hs_gen_index (DWORD ltime)
static INT	hs_search_file (DWORD *ltime, INT direction)
static INT	hs_define_event (DWORD event_id, const char *name, const TAG *tag, DWORD size)
static INT	hs_write_event (DWORD event_id, const void *data, DWORD size)
static INT	hs_enum_events (DWORD ltime, char *event_name, DWORD *name_size, INT event_id[], DWORD *id_size)
static INT	hs_count_events (DWORD ltime, DWORD *count)
static INT	hs_get_event_id (DWORD ltime, const char *name, DWORD *id)
static INT	hs_count_vars (DWORD ltime, DWORD event_id, DWORD *count)
static INT	hs_enum_vars (DWORD ltime, DWORD event_id, char *var_name, DWORD *size, DWORD *var_n, DWORD *n_size)
static INT	hs_get_var (DWORD ltime, DWORD event_id, const char *var_name, DWORD *type, INT *n_data)
static INT	hs_get_tags (DWORD ltime, DWORD event_id, char event_name[NAME_LENGTH], int *n_tags, TAG **tags)
double	hs_to_double (int tid, const void *ybuffer)
static INT	hs_read (DWORD event_id, DWORD start_time, DWORD end_time, DWORD interval, const char *tag_name, DWORD var_index, DWORD *time_buffer, DWORD *tbsize, void *data_buffer, DWORD *dbsize, DWORD *data_type, DWORD *data_n, MidasHistoryBufferInterface *buffer)
static INT	hs_dump (DWORD event_id, DWORD start_time, DWORD end_time, DWORD interval, BOOL binary_time)
	MidasHistory::MidasHistory ()
	MidasHistory::~MidasHistory ()
int	MidasHistory::hs_connect (const char *path)
	returns HS_SUCCESS
int	MidasHistory::hs_disconnect ()
	disconnect from history, returns HS_SUCCESS
int	MidasHistory::hs_set_debug (int debug)
	set debug level, returns previous debug level
int	MidasHistory::hs_clear_cache ()
	clear internal cache, returns HS_SUCCESS
int	MidasHistory::FindEventId (const char *event_name)
int	MidasHistory::AllocateEventId (const char *event_name)
int	MidasHistory::CreateOdbTags (int event_id, const char *event_name, int ntags, const TAG tags[])
int	MidasHistory::hs_define_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])
	see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	MidasHistory::hs_write_event (const char *event_name, time_t timestamp, int data_size, const char *data)
	see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	MidasHistory::hs_flush_buffers ()
	flush buffered data to storage where it is visible to mhttpd
int	MidasHistory::GetEventsFromOdbEvents (std::vector< std::string > *events)
int	MidasHistory::GetEventsFromOdbTags (std::vector< std::string > *events)
int	MidasHistory::hs_get_events (time_t t, std::vector< std::string > *pevents)
	get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS
int	MidasHistory::GetEventIdFromHS (time_t ltime, const char *evname, const char *tagname)
int	MidasHistory::GetEventIdFromOdbTags (const char *evname, const char *tagname)
int	MidasHistory::GetEventId (time_t t, const char *event_name, const char *tag_name, int *pevid)
int	MidasHistory::GetTagsFromHS (const char *event_name, std::vector< TAG > *ptags)
int	MidasHistory::GetTagsFromOdb (const char *event_name, std::vector< TAG > *ptags)
int	MidasHistory::hs_get_tags (const char *event_name, time_t t, std::vector< TAG > *ptags)
	get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns HS_SUCCESS
int	MidasHistory::hs_get_last_written (time_t start_time, int num_var, const char *const event_name[], const char *const tag_name[], const int var_index[], time_t last_written[])
int	MidasHistory::hs_read (time_t start_time, time_t end_time, time_t interval, int num_var, const char *const event_name[], const char *const tag_name[], const int var_index[], int num_entries[], time_t *time_buffer[], double *data_buffer[], int read_status[])
	see hs_read(), returns HS_SUCCESS
int	MidasHistory::hs_read_buffer (time_t start_time, time_t end_time, int num_var, const char *const event_name[], const char *const tag_name[], const int var_index[], MidasHistoryBufferInterface *buffer[], int read_status[])
	returns HS_SUCCESS
int	MidasHistory::hs_read_binned (time_t start_time, time_t end_time, int num_bins, int num_var, const char *const event_name[], const char *const tag_name[], const int var_index[], int num_entries[], int *count_bins[], double *mean_bins[], double *rms_bins[], double *min_bins[], double *max_bins[], time_t *bins_first_time[], double *bins_first_value[], time_t *bins_last_time[], double *bins_last_value[], time_t last_time[], double last_value[], int read_status[])
	returns HS_SUCCESS
INT	hs_define_panel (const char *group, const char *panel, const std::vector< std::string > var)
INT	hs_define_panel2 (const char *group, const char *panel, const std::vector< std::string > var, const std::vector< std::string > label, const std::vector< std::string > formula, const std::vector< std::string > color)
MidasHistoryInterface *	MakeMidasHistory ()

Variables
static std::vector< HISTORY * >	_history
static std::string	_hs_path_name
HNDLE	MidasHistory::fDB
int	MidasHistory::fDebug
std::vector< std::string >	MidasHistory::fEventsCache
std::map< std::string, std::vector< TAG > >	MidasHistory::fTagsCache
std::map< std::string, int >	MidasHistory::fEvidCache

Detailed Description

dox

Macro Definition Documentation

HISTORY_PANEL

#define HISTORY_PANEL

(

_name

)

Value:

const char *_name[] = {\
"[.]",\
"Variables = STRING : [64] :",\
"Timescale = STRING : [32] 10m",\
"Zero ylow = BOOL : n",\
"Show run markers = BOOL : y",\
"Buttons = STRING[7] :",\
"[32] 10m",\
"[32] 1h",\
"[32] 3h",\
"[32] 12h",\
"[32] 24h",\
"[32] 3d",\
"[32] 7d",\
"Log axis = BOOL : n",\
"Show values = BOOL : y",\
"Sort vars = BOOL : n",\
"Show old vars = BOOL : n",\
"Minimum = DOUBLE : -inf",\
"Maximum = DOUBLE : inf",\
"Label = STRING : [32] ",\
"Colour = STRING : [32] ",\
"Formula = STRING : [64] ",\
"Show fill = BOOL : y",\
"",\
NULL }

Define history panel in ODB with certain variables and default values for everything else

Parameters

group	History group name
panel	Historyh panel name
var	Vector of variables

Returns

HS_SUCCESS

Definition at line 3454 of file history.cxx.

                                                   {\
"[.]",\
"Variables = STRING : [64] :",\
"Timescale = STRING : [32] 10m",\
"Zero ylow = BOOL : n",\
"Show run markers = BOOL : y",\
"Buttons = STRING[7] :",\
"[32] 10m",\
"[32] 1h",\
"[32] 3h",\
"[32] 12h",\
"[32] 24h",\
"[32] 3d",\
"[32] 7d",\
"Log axis = BOOL : n",\
"Show values = BOOL : y",\
"Sort vars = BOOL : n",\
"Show old vars = BOOL : n",\
"Minimum = DOUBLE : -inf",\
"Maximum = DOUBLE : inf",\
"Label = STRING : [32] ",\
"Colour = STRING : [32] ",\
"Formula = STRING : [64] ",\
"Show fill = BOOL : y",\
"",\
NULL }

Function Documentation

MidasHistory()

MidasHistory::MidasHistory ( )

inline

Definition at line 2228 of file history.cxx.

   {
      fDebug = 0;
   }

~MidasHistory()

MidasHistory::~MidasHistory ( )

inline

Definition at line 2233 of file history.cxx.

   {
      // empty
   }

AllocateEventId()

int MidasHistory::AllocateEventId ( const char *  event_name )

inline

Definition at line 2334 of file history.cxx.

   {
      int status;
      char name[256];
      mstrlcpy(name, event_name, sizeof(name));
      char *s = strchr(name, '/');
      if (s)
         *s = ':';
      
      // special event id for run transitions
      if (strcmp(name, "Run transitions")==0) {
         status = db_set_value(fDB, 0, "/History/Events/0", name, strlen(name)+1, 1, TID_STRING);
         assert(status == DB_SUCCESS);
         return 0;
      }
 
      if (1) {
         std::string tmp = msprintf("/Equipment/%s/Common/Event ID", name);
 
         WORD evid = 0;
         int size = sizeof(evid);
         status = db_get_value(fDB, 0, tmp.c_str(), &evid, &size, TID_WORD, FALSE);
         if (status == DB_SUCCESS) {
 
            std::string he = msprintf("/History/Events/%d", evid);
 
            std::string xname;
            status = db_get_value_string(fDB, 0, he.c_str(), 0, &xname);
            if (status == DB_SUCCESS && xname != event_name) {
               cm_msg(MERROR, "add_event", "History events \"%s\" and \"%s\" use the same history event id %d. If both equipments write to the history, their data will be mixed up. To fix this, enable per-variable history, turn off the \"MIDAS\" history (use \"FILE\" history) or change event IDs or set \"common/log history\" to zero", event_name, xname.c_str(), evid);
            }
 
            status = db_set_value(fDB, 0, he.c_str(), name, strlen(name)+1, 1, TID_STRING);
            assert(status == DB_SUCCESS);
 
            //printf("AllocateEventId: event [%s] allocated common/event id %d\n", event_name, evid);
 
            return evid;
         }
      }
 
      for (int evid = 101; evid < 65000; evid++) {
         char tmp[256];
         HNDLE hKey;
 
         sprintf(tmp,"/History/Events/%d", evid);
 
         status = db_find_key(fDB, 0, tmp, &hKey);
         if (status != DB_SUCCESS) {
 
            status = db_set_value(fDB, 0, tmp, name, strlen(name)+1, 1, TID_STRING);
            assert(status == DB_SUCCESS);
 
            //printf("AllocateEventId: event [%s] allocated next sequential id %d\n", event_name, evid);
 
            return evid;
         }
      }
 
      cm_msg(MERROR, "AllocateEventId", "Cannot allocate history event id - all in use - please examine /History/Events");
      return -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

CreateOdbTags()

int MidasHistory::CreateOdbTags ( int  event_id, const char *  event_name, int  ntags, const TAG  tags[]  )

inline

Definition at line 2399 of file history.cxx.

   {
      int disableTags;
      int oldTags;
      int size, status;
 
      /* create history tags for mhttpd */
 
      disableTags = 0;
      size = sizeof(disableTags);
      status = db_get_value(fDB, 0, "/History/DisableTags", &disableTags, &size, TID_BOOL, TRUE);
 
      oldTags = 0;
      size = sizeof(oldTags);
      status = db_get_value(fDB, 0, "/History/CreateOldTags", &oldTags, &size, TID_BOOL, FALSE);
 
      if (disableTags) {
         status = db_delete(fDB, 0, "/History/Tags");
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "add_event", "Cannot delete /History/Tags, db_delete() status %d", status);
         }
      } else if (oldTags) {
 
         char buf[256];
 
         sprintf(buf, "/History/Tags/%d", event_id);
 
         //printf("Set tag \'%s\' = \'%s\'\n", buf, event_name);
 
         status = db_set_value(fDB, 0, buf, (void*)event_name, strlen(event_name)+1, 1, TID_STRING);
         assert(status == DB_SUCCESS);
 
         for (int i=0; i<ntags; i++) {
            WORD v = (WORD) tags[i].n_data;
            sprintf(buf, "/History/Tags/Tags %d/%s", event_id, tags[i].name);
 
            //printf("Set tag \'%s\' = %d\n", buf, v);
 
            status = db_set_value(fDB, 0, buf, &v, sizeof(v), 1, TID_WORD);
            assert(status == DB_SUCCESS);
 
            if (strlen(tags[i].name) == NAME_LENGTH-1)
               cm_msg(MERROR, "add_event",
                      "Tag name \'%s\' in event %d (%s) may have been truncated to %d characters",
                      tags[i].name, event_id, event_name, NAME_LENGTH-1);
         }
 
      } else {
 
         const int kLength = 32 + NAME_LENGTH + NAME_LENGTH;
         char buf[kLength];
         HNDLE hKey;
 
         sprintf(buf, "/History/Tags/%d", event_id);
         status = db_find_key(fDB, 0, buf, &hKey);
 
         if (status == DB_SUCCESS) {
            // add new tags
            KEY key;
 
            status = db_get_key(fDB, hKey, &key);
            assert(status == DB_SUCCESS);
 
            assert(key.type == TID_STRING);
 
            if (key.item_size < kLength && key.num_values == 1) {
               // old style tags are present. Convert them to new style!
 
               HNDLE hTags;
 
               cm_msg(MINFO, "add_event", "Converting old event %d (%s) tags to new style", event_id, event_name);
 
               mstrlcpy(buf, event_name, kLength);
 
               status = db_set_data(fDB, hKey, buf, kLength, 1, TID_STRING);
               assert(status == DB_SUCCESS);
 
               sprintf(buf, "/History/Tags/Tags %d", event_id);
 
               status = db_find_key(fDB, 0, buf, &hTags);
 
               if (status == DB_SUCCESS) {
                  for (int i=0; ; i++) {
                     HNDLE h;
                     int size;
                     KEY key;
                     WORD w;
 
                     status = db_enum_key(fDB, hTags, i, &h);
                     if (status == DB_NO_MORE_SUBKEYS)
                        break;
                     assert(status == DB_SUCCESS);
 
                     status = db_get_key(fDB, h, &key);
 
                     size = sizeof(w);
                     status = db_get_data(fDB, h, &w, &size, TID_WORD);
                     assert(status == DB_SUCCESS);
 
                     sprintf(buf, "%d[%d] %s", 0, w, key.name);
                  
                     status = db_set_data_index(fDB, hKey, buf, kLength, 1+i, TID_STRING);
                     assert(status == DB_SUCCESS);
                  }
 
                  status = db_delete_key(fDB, hTags);
                  assert(status == DB_SUCCESS);
               }
 
               // format conversion has changed the key, get it again
               status = db_get_key(fDB, hKey, &key);
               assert(status == DB_SUCCESS);
            }
 
            if (1) {
               // add new tags
         
               int size = key.item_size * key.num_values;
               int num = key.num_values;
 
               char* s = (char*)malloc(size);
               assert(s != NULL);
 
               TAG* t = (TAG*)malloc(sizeof(TAG)*(key.num_values + ntags));
               assert(t != NULL);
 
               status = db_get_data(fDB, hKey, s, &size, TID_STRING);
               assert(status == DB_SUCCESS);
 
               for (int i=1; i<key.num_values; i++) {
                  char* ss = s + i*key.item_size;
 
                  t[i].type = 0;
                  t[i].n_data = 0;
                  t[i].name[0] = 0;
 
                  if (isdigit(ss[0])) {
                     //sscanf(ss, "%d[%d] %s", &t[i].type, &t[i].n_data, t[i].name);
 
                     t[i].type = strtoul(ss, &ss, 0);
                     assert(*ss == '[');
                     ss++;
                     t[i].n_data = strtoul(ss, &ss, 0);
                     assert(*ss == ']');
                     ss++;
                     assert(*ss == ' ');
                     ss++;
                     mstrlcpy(t[i].name, ss, sizeof(t[i].name));
 
                     //printf("type %d, n_data %d, name [%s]\n", t[i].type, t[i].n_data, t[i].name);
                  }
               }
 
               for (int i=0; i<ntags; i++) {
                  int k = 0;
 
                  for (int j=1; j<key.num_values; j++) {
                     if (equal_ustring((char*)tags[i].name, (char*)t[j].name)) {
                        if ((tags[i].type!=t[j].type) || (tags[i].n_data!=t[j].n_data)) {
                           cm_msg(MINFO, "add_event", "Event %d (%s) tag \"%s\" type and size changed from %d[%d] to %d[%d]",
                                  event_id, event_name,
                                  tags[i].name,
                                  t[j].type, t[j].n_data,
                                  tags[i].type, tags[i].n_data);
                           k = j;
                           break;
                        }
 
                        k = -1;
                        break;
                     }
                  }
 
                  // if tag not present, k==0, so append it to the array
 
                  if (k==0)
                     k = num;
 
                  if (k > 0) {
                     sprintf(buf, "%d[%d] %s", tags[i].type, tags[i].n_data, tags[i].name);
 
                     status = db_set_data_index(fDB, hKey, buf, kLength, k, TID_STRING);
                     assert(status == DB_SUCCESS);
 
                     if (k >= num)
                        num = k+1;
                  }
               }
 
               free(s);
               free(t);
            }
 
         } else if (status == DB_NO_KEY) {
            // create new array of tags
            status = db_create_key(fDB, 0, buf, TID_STRING);
            assert(status == DB_SUCCESS);
 
            status = db_find_key(fDB, 0, buf, &hKey);
            assert(status == DB_SUCCESS);
 
            mstrlcpy(buf, event_name, kLength);
 
            status = db_set_data(fDB, hKey, buf, kLength, 1, TID_STRING);
            assert(status == DB_SUCCESS);
 
            for (int i=0; i<ntags; i++) {
               sprintf(buf, "%d[%d] %s", tags[i].type, tags[i].n_data, tags[i].name);
 
               status = db_set_data_index(fDB, hKey, buf, kLength, 1+i, TID_STRING);
               assert(status == DB_SUCCESS);
            }
         } else {
            cm_msg(MERROR, "add_event", "Error: db_find_key(%s) status %d", buf, status);
            return HS_FILE_ERROR;
         }
      }
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

FindEventId()

int MidasHistory::FindEventId ( const char *  event_name )

inline

Definition at line 2286 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
      char name[256];
      mstrlcpy(name, event_name, sizeof(name));
      char *s = strchr(name, '/');
      if (s)
         *s = ':';
 
      //printf("Looking for event id for \'%s\'\n", name);
   
      status = db_find_key(fDB, 0, "/History/Events", &hKeyRoot);
      if (status == DB_SUCCESS) {
         for (int i = 0;; i++) {
            HNDLE hKey;
            KEY key;
         
            status = db_enum_key(fDB, hKeyRoot, i, &hKey);
            if (status != DB_SUCCESS)
               break;
         
            status = db_get_key(fDB, hKey, &key);
            assert(status == DB_SUCCESS);
         
            //printf("key \'%s\'\n", key.name);
 
            int evid = (WORD) strtol(key.name, NULL, 0);
            if (evid == 0)
               continue;
 
            char tmp[NAME_LENGTH+NAME_LENGTH+2];
            int size = sizeof(tmp);
            status = db_get_data(fDB, hKey, tmp, &size, TID_STRING);
            assert(status == DB_SUCCESS);
 
            //printf("got %d \'%s\' looking for \'%s\'\n", evid, tmp, name);
 
            if (equal_ustring(name, tmp))
               return evid;
         }
      }
 
      return -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventId()

int MidasHistory::GetEventId ( time_t  t, const char *  event_name, const char *  tag_name, int *  pevid  )

inline

Definition at line 2938 of file history.cxx.

   {
      int event_id = -1;
 
      if (fDebug && event_name != NULL && tag_name != NULL)
         printf("xhs_event_id for event [%s], tag [%s]\n", event_name, tag_name);
 
      *pevid = 0;
 
      /* use "/History/Tags" if available */
      event_id = GetEventIdFromOdbTags(event_name, tag_name);
      
      /* if no Tags, use "/History/Events" and hs_get_tags() to read definition from history files */
      if (event_id < 0)
         event_id = GetEventIdFromHS(t, event_name, tag_name);
 
      /* if nothing works, use hs_get_event_id() */
      if (event_id <= 0) {
         DWORD evid = 0;
         int status = ::hs_get_event_id((DWORD)t, (char*)event_name, &evid);
         if (status != HS_SUCCESS)
            return status;
         event_id = evid;
      }
      
      if (event_id < 0)
         return HS_UNDEFINED_VAR;
      
      *pevid = event_id;
      
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventIdFromHS()

int MidasHistory::GetEventIdFromHS ( time_t  ltime, const char *  evname, const char *  tagname  )

inline

Definition at line 2794 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
 
      status = db_find_key(fDB, 0, "/History/Events", &hKeyRoot);
      if (status != DB_SUCCESS) {
         return -1;
      }
 
      for (int i = 0;; i++) {
         HNDLE hKey;
         KEY key;
         int  evid;
         char buf[256];
         int size;
         char *s;
         int ntags = 0;
         TAG* tags = NULL;
         char event_name[NAME_LENGTH];
 
         status = db_enum_key(fDB, hKeyRoot, i, &hKey);
         if (status != DB_SUCCESS)
            break;
 
         status = db_get_key(fDB, hKey, &key);
         assert(status == DB_SUCCESS);
 
         if (!isdigit(key.name[0]))
            continue;
 
         evid = atoi(key.name);
 
         assert(key.item_size < (int)sizeof(buf));
 
         size = sizeof(buf);
         status = db_get_data(fDB, hKey, buf, &size, TID_STRING);
         assert(status == DB_SUCCESS);
 
         mstrlcpy(event_name, buf, sizeof(event_name));
 
         s = strchr(buf,':');
         if (s)
            *s = 0;
 
         //printf("Found event %d, event [%s] name [%s], looking for [%s][%s]\n", evid, event_name, buf, evname, tagname);
 
         if (!equal_ustring((char *)evname, buf))
            continue;
 
         status = ::hs_get_tags((DWORD)ltime, evid, event_name, &ntags, &tags);
 
         for (int j=0; j<ntags; j++) {
            //printf("at %d [%s] looking for [%s]\n", j, tags[j].name, tagname);
 
            if (equal_ustring((char *)tagname, tags[j].name)) {
               if (tags)
                  free(tags);
               return evid;
            }
         }
 
         if (tags)
            free(tags);
         tags = NULL;
      }
 
      return -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventIdFromOdbTags()

int MidasHistory::GetEventIdFromOdbTags ( const char *  evname, const char *  tagname  )

inline

Definition at line 2864 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
      
      status = db_find_key(fDB, 0, "/History/Tags", &hKeyRoot);
      if (status != DB_SUCCESS) {
         return -1;
      }
 
      for (int i = 0;; i++) {
         HNDLE hKey;
         KEY key;
         int evid;
         char buf[256];
         int size;
         char *s;
 
         status = db_enum_key(fDB, hKeyRoot, i, &hKey);
         if (status != DB_SUCCESS)
            break;
 
         status = db_get_key(fDB, hKey, &key);
         assert(status == DB_SUCCESS);
 
         if (key.type != TID_STRING)
            continue;
 
         if (!isdigit(key.name[0]))
            continue;
 
         evid = atoi(key.name);
 
         assert(key.item_size < (int)sizeof(buf));
 
         size = sizeof(buf);
         status = db_get_data_index(fDB, hKey, buf, &size, 0, TID_STRING);
         assert(status == DB_SUCCESS);
 
         s = strchr(buf,'/');
         if (s)
            *s = 0;
 
         //printf("Found event %d, name [%s], looking for [%s][%s]\n", evid, buf, evname, tagname);
 
         if (!equal_ustring((char *)evname, buf))
            continue;
 
         for (int j=1; j<key.num_values; j++) {
            size = sizeof(buf);
            status = db_get_data_index(fDB, hKey, buf, &size, j, TID_STRING);
            assert(status == DB_SUCCESS);
 
            if (!isdigit(buf[0]))
               continue;
 
            s = strchr(buf,' ');
            if (!s)
               continue;
 
            s++;
 
            //printf("at %d [%s] [%s] compare to [%s]\n", j, buf, s, tagname);
 
            if (equal_ustring((char *)tagname, s)) {
               //printf("Found evid %d\n", evid);
               return evid;
            }
         }
      }
 
      return -1;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventsFromOdbEvents()

int MidasHistory::GetEventsFromOdbEvents ( std::vector< std::string > *  events )

inline

Definition at line 2653 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
 
      status = db_find_key(fDB, 0, "/History/Events", &hKeyRoot);
      if (status != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
 
      /* loop over tags to display event names */
      for (int i = 0;; i++) {
         HNDLE hKeyEq;
         char *s;
         char evname[1024+NAME_LENGTH];
         int size;
      
         status = db_enum_key(fDB, hKeyRoot, i, &hKeyEq);
         if (status != DB_SUCCESS)
            break;
    
         size = sizeof(evname);
         status = db_get_data(fDB, hKeyEq, evname, &size, TID_STRING);
         assert(status == DB_SUCCESS);
 
         s = strchr(evname,':');
         if (s)
            *s = '/';
 
         /* skip duplicated event names */
 
         int found = 0;
         for (unsigned i=0; i<events->size(); i++) {
            if (equal_ustring(evname, (*events)[i].c_str())) {
               found = 1;
               break;
            }
         }
    
         if (found)
            continue;
 
         events->push_back(evname);
 
         //printf("event \'%s\'\n", evname);
      }
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetEventsFromOdbTags()

int MidasHistory::GetEventsFromOdbTags ( std::vector< std::string > *  events )

inline

Definition at line 2703 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
 
      status = db_find_key(fDB, 0, "/History/Tags", &hKeyRoot);
      if (status != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
   
      /* loop over tags to display event names */
      for (int i = 0;; i++) {
         HNDLE hKeyEq;
         KEY key;
         char *s;
         WORD event_id;
         char evname[1024+NAME_LENGTH];
         int size;
      
         status = db_enum_key(fDB, hKeyRoot, i, &hKeyEq);
         if (status != DB_SUCCESS)
            break;
    
         /* get event name */
         db_get_key(fDB, hKeyEq, &key);
      
         //printf("key \'%s\'\n", key.name);
      
         if (key.type != TID_STRING)
            continue;
 
         /* parse event name in format: "event_id" or "event_id:var_name" */
         s = key.name;
      
         event_id = (WORD)strtoul(s,&s,0);
         if (event_id == 0)
            continue;
         if (s[0] != 0)
            continue;
 
         size = sizeof(evname);
         status = db_get_data_index(fDB, hKeyEq, evname, &size, 0, TID_STRING);
         assert(status == DB_SUCCESS);
 
         /* skip duplicated event names */
 
         int found = 0;
         for (unsigned i=0; i<events->size(); i++) {
            if (equal_ustring(evname, (*events)[i].c_str())) {
               found = 1;
               break;
            }
         }
    
         if (found)
            continue;
 
         events->push_back(evname);
 
         //printf("event %d \'%s\'\n", event_id, evname);
      }
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetTagsFromHS()

int MidasHistory::GetTagsFromHS ( const char *  event_name, std::vector< TAG > *  ptags  )

inline

Definition at line 2971 of file history.cxx.

   {
      time_t now = time(NULL);
      int evid;
      int status = GetEventId(now, event_name, NULL, &evid);
      if (status != HS_SUCCESS)
         return status;
      
      if (fDebug)
         printf("hs_get_tags: get tags for event [%s] %d\n", event_name, evid);
      
      int ntags;
      TAG* tags;
      status =  ::hs_get_tags((DWORD)now, evid, (char*)event_name, &ntags, &tags);
      
      if (status != HS_SUCCESS)
         return status;
      
      for (int i=0; i<ntags; i++)
         ptags->push_back(tags[i]);
      
      if (tags)
         free(tags);
      
      if (fDebug)
         printf("hs_get_tags: get tags for event [%s] %d, found %d tags\n", event_name, evid, ntags);
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

GetTagsFromOdb()

int MidasHistory::GetTagsFromOdb ( const char *  event_name, std::vector< TAG > *  ptags  )

inline

Definition at line 3001 of file history.cxx.

   {
      HNDLE hKeyRoot;
      int status;
 
      status = db_find_key(fDB, 0, "/History/Tags", &hKeyRoot);
      if (status != DB_SUCCESS) {
         return HS_FILE_ERROR;
      }
   
      /* loop over equipment to display event name */
      for (int i = 0;; i++) {
         HNDLE hKey;
         KEY key;
         WORD event_id;
         char buf[256];
         int size;
         char* s;
      
         status = db_enum_key(fDB, hKeyRoot, i, &hKey);
         if (status != DB_SUCCESS)
            break;
    
         /* get event name */
         status = db_get_key(fDB, hKey, &key);
         assert(status == DB_SUCCESS);
      
         /* parse event id */
         if (!isdigit(key.name[0]))
            continue;
 
         event_id = atoi(key.name);
         if (event_id == 0)
            continue;
 
         if (key.item_size >= (int)sizeof(buf))
            continue;
 
         if (key.num_values == 1) { // old format of "/History/Tags"
 
            HNDLE hKeyDir;
            sprintf(buf, "Tags %d", event_id);
            status = db_find_key(fDB, hKeyRoot, buf, &hKeyDir);
            if (status != DB_SUCCESS)
               continue;
 
            /* loop over tags */
            for (int j=0; ; j++) {
               HNDLE hKey;
               WORD array;
               int size;
               char var_name[NAME_LENGTH];
            
               status = db_enum_key(fDB, hKeyDir, j, &hKey);
               if (status != DB_SUCCESS)
                  break;
            
               /* get event name */
               status = db_get_key(fDB, hKey, &key);
               assert(status == DB_SUCCESS);
            
               array = 1;
               size  = sizeof(array);
               status = db_get_data(fDB, hKey, &array, &size, TID_WORD);
               assert(status == DB_SUCCESS);
            
               mstrlcpy(var_name, key.name, sizeof(var_name));
            
               //printf("Found %s, event %d (%s), tag (%s) array %d\n", key.name, event_id, event_name, var_name, array);
            
               TAG t;
               mstrlcpy(t.name, var_name, sizeof(t.name));
               t.n_data = array;
               t.type = 0;
               
               ptags->push_back(t);
            }
 
            continue;
         }
 
         if (key.type != TID_STRING)
            continue;
 
         size = sizeof(buf);
         status = db_get_data_index(fDB, hKey, buf, &size, 0, TID_STRING);
         assert(status == DB_SUCCESS);
 
         if (strchr(event_name, '/')==NULL) {
            char* s = strchr(buf, '/');
            if (s)
               *s = 0;
         }
 
         //printf("evid %d, name [%s]\n", event_id, buf);
 
         if (!equal_ustring(buf, event_name))
            continue;
 
         /* loop over tags */
         for (int j=1; j<key.num_values; j++) {
            int array;
            int size;
            char var_name[NAME_LENGTH];
            int ev_type;
         
            size = sizeof(buf);
            status = db_get_data_index(fDB, hKey, buf, &size, j, TID_STRING);
            assert(status == DB_SUCCESS);
 
            //printf("index %d [%s]\n", j, buf);
 
            if (!isdigit(buf[0]))
               continue;
 
            sscanf(buf, "%d[%d]", &ev_type, &array);
 
            s = strchr(buf, ' ');
            if (!s)
               continue;
            s++;
 
            mstrlcpy(var_name, s, sizeof(var_name));
 
            TAG t;
            mstrlcpy(t.name, var_name, sizeof(t.name));
            t.n_data = array;
            t.type = ev_type;
 
            //printf("Found %s, event %d, tag (%s) array %d, type %d\n", buf, event_id, var_name, array, ev_type);
 
            ptags->push_back(t);
         }
      }
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hs_clear_cache()

int MidasHistory::hs_clear_cache ( )

inlinevirtual

clear internal cache, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2273 of file history.cxx.

   {
      if (fDebug)
         printf("hs_clear_cache!\n");
 
      fEventsCache.clear();
      fTagsCache.clear();
      fEvidCache.clear();
      return HS_SUCCESS;
   }

Here is the caller graph for this function:

hs_connect()

int MidasHistory::hs_connect ( const char *  connect_string )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2240 of file history.cxx.

   {
      cm_get_experiment_database(&fDB, NULL);
 
      /* delete obsolete odb entries */
 
      db_delete(fDB, 0, "/History/ListSource");
 
      ::hs_set_path(path);
 
      if (fDebug)
         printf("hs_connect: path [%s]\n", path);
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

hs_count_events()

static INT hs_count_events ( DWORD  ltime, DWORD *  count  )

static

Definition at line 907 of file history.cxx.

{
   int fh, fhd;
   std::string fn, fnd;
   INT status, i, n;
   DWORD *id;
   DEF_RECORD def_rec;
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_count_events", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_count_events", "cannot open index files");
      return HS_FILE_ERROR;
   }
 
   /* allocate event id array */
   xseek_end(fnd, fhd);
   DWORD pos_fhd = xcurpos(fnd, fhd);
   if (pos_fhd == (DWORD)-1) return HS_FILE_ERROR;
   id = (DWORD *) M_MALLOC(pos_fhd/sizeof(def_rec) * sizeof(DWORD));
   xseek(fnd, fhd, 0);
 
   /* loop over index file */
   n = 0;
   do {
      /* read definition index record */
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec), true) <= 0)
         break;
 
      /* look for existing entries */
      for (i = 0; i < n; i++)
         if (id[i] == def_rec.event_id)
            break;
 
      /* new entry found */
      if (i == n) {
         id[i] = def_rec.event_id;
         n++;
      }
   } while (TRUE);
 
 
   M_FREE(id);
   close(fh);
   close(fhd);
   *count = n;
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_count_vars()

static INT hs_count_vars ( DWORD  ltime, DWORD  event_id, DWORD *  count  )

static

Definition at line 1060 of file history.cxx.

{
   int fh, fhd;
   std::string fn, fnd;
   INT i, n, status;
   DEF_RECORD def_rec;
   HIST_RECORD rec;
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_count_tags", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_count_tags", "cannot open index files");
      return HS_FILE_ERROR;
   }
 
   /* search last definition */
   xseek_end(fnd, fhd);
   n = xcurpos(fnd, fhd) / sizeof(def_rec);
   def_rec.event_id = 0;
   for (i = n - 1; i >= 0; i--) {
      if (!xseek(fnd, fhd, i * sizeof(def_rec))) return HS_FILE_ERROR;
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec)) < 0) return HS_FILE_ERROR;
      if (def_rec.event_id == event_id)
         break;
   }
   if (def_rec.event_id != event_id) {
      cm_msg(MERROR, "hs_count_tags", "event %d not found in index file", event_id);
      return HS_FILE_ERROR;
   }
 
   /* read definition */
   xseek(fn, fh, def_rec.def_offset);
   xread(fn, fh, (char *) &rec, sizeof(rec));
   *count = rec.data_size / sizeof(TAG);
 
   close(fh);
   close(fhd);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_define_event() [1/2]

int MidasHistory::hs_define_event ( const char *  event_name, time_t  timestamp, int  ntags, const TAG  tags[]  )

inlinevirtual

see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 2622 of file history.cxx.

   {
      int event_id = FindEventId(event_name);
      if (event_id < 0)
         event_id = AllocateEventId(event_name);
      if (event_id < 0)
         return HS_FILE_ERROR;
      fEvidCache[event_name] = event_id;
      CreateOdbTags(event_id, event_name, ntags, tags);
      return ::hs_define_event(event_id, (char*)event_name, (TAG*)tags, ntags*sizeof(TAG));
   }

Here is the call graph for this function:

hs_define_event() [2/2]

static INT hs_define_event ( DWORD  event_id, const char *  name, const TAG *  tag, DWORD  size  )

static

Definition at line 427 of file history.cxx.

{
   {
      HIST_RECORD rec, prev_rec;
      DEF_RECORD def_rec;
      time_t ltime;
      char str[256], event_name[NAME_LENGTH], *buffer;
      int fh, fhi, fhd;
      std::string fn, fni, fnd;
      INT n, status, semaphore;
 
      //printf("hs_define_event: event_id %d, name [%s]\n", event_id, name);
 
      /* request semaphore */
      cm_get_experiment_semaphore(NULL, NULL, &semaphore, NULL);
      status = ss_semaphore_wait_for(semaphore, 5 * 1000);
      if (status != SS_SUCCESS)
         return SUCCESS;        /* someone else blocked the history system */
 
      /* allocate new space for the new history descriptor */
      /* check if history already open */
      int index = -1;
      for (unsigned i = 0; i < _history.size(); i++)
         if (_history[i]->event_id == event_id) {
            index = i;
            break;
         }
 
      /* if not found, create new one */
      if (index < 0) {
         index = _history.size();
         _history.push_back(new HISTORY);
      }
 
      /* assemble definition record header */
      rec.record_type = RT_DEF;
      rec.event_id = event_id;
      rec.time = (DWORD) time(NULL);
      rec.data_size = size;
      mstrlcpy(event_name, name, NAME_LENGTH);
 
      /* if history structure not set up, do so now */
      if (!_history[index]->hist_fh) {
         /* open history file */
         hs_open_file(rec.time, "hst", O_CREAT | O_RDWR, &fn, &fh);
         if (fh < 0) {
            ss_semaphore_release(semaphore);
            return HS_FILE_ERROR;
         }
 
         /* open index files */
         hs_open_file(rec.time, "idf", O_CREAT | O_RDWR, &fnd, &fhd);
         hs_open_file(rec.time, "idx", O_CREAT | O_RDWR, &fni, &fhi);
         xseek_end(fn, fh);
         xseek_end(fni, fhi);
         xseek_end(fnd, fhd);
 
         DWORD fh_pos = xcurpos(fn, fh);
         DWORD fhd_pos = xcurpos(fnd, fhd);
 
         if (fh_pos == (DWORD)-1) return HS_FILE_ERROR;
         if (fhd_pos == (DWORD)-1) return HS_FILE_ERROR;
 
         /* regenerate index if missing */
         if (fh_pos > 0 && fhd_pos == 0) {
            close(fh);
            close(fhi);
            close(fhd);
            hs_gen_index(rec.time);
            hs_open_file(rec.time, "hst", O_RDWR, &fn, &fh);
            hs_open_file(rec.time, "idx", O_RDWR, &fni, &fhi);
            hs_open_file(rec.time, "idf", O_RDWR, &fnd, &fhd);
            xseek_end(fn, fh);
            xseek_end(fni, fhi);
            xseek_end(fnd, fhd);
         }
 
         ltime = (time_t) rec.time;
         struct tm tmb;
         localtime_r(&ltime, &tmb);
         tmb.tm_hour = tmb.tm_min = tmb.tm_sec = 0;
 
         DWORD pos = xcurpos(fn, fh);
         if (pos == (DWORD)-1) return HS_FILE_ERROR;
 
         /* setup history structure */
         _history[index]->hist_fn = fn;
         _history[index]->index_fn = fni;
         _history[index]->def_fn = fnd;
         _history[index]->hist_fh = fh;
         _history[index]->index_fh = fhi;
         _history[index]->def_fh = fhd;
         _history[index]->def_offset = pos;
         _history[index]->event_id = event_id;
         _history[index]->event_name = event_name;
         _history[index]->base_time = (DWORD) ss_mktime(&tmb);
         _history[index]->n_tag = size / sizeof(TAG);
         _history[index]->tag = (TAG *) M_MALLOC(size);
         memcpy(_history[index]->tag, tag, size);
 
         /* search previous definition */
         fhd_pos = xcurpos(fnd, fhd);
         if (fhd_pos == (DWORD)-1) return HS_FILE_ERROR;
         n = fhd_pos / sizeof(def_rec);
         def_rec.event_id = 0;
         for (int i = n - 1; i >= 0; i--) {
            if (!xseek(fnd, fhd, i * sizeof(def_rec))) return HS_FILE_ERROR;
            if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec)) < 0) return HS_FILE_ERROR;
            if (def_rec.event_id == event_id)
               break;
         }
         xseek_end(fnd, fhd);
 
         /* if definition found, compare it with new one */
         if (def_rec.event_id == event_id) {
            buffer = (char *) M_MALLOC(size);
            memset(buffer, 0, size);
 
            xseek(fn, fh, def_rec.def_offset);
            xread(fn, fh, (char *) &prev_rec, sizeof(prev_rec));
            xread(fn, fh, str, NAME_LENGTH);
            xread(fn, fh, buffer, size);
            xseek_end(fn, fh);
 
            if (prev_rec.data_size != size || strcmp(str, event_name) != 0 || memcmp(buffer, tag, size) != 0) {
               /* write definition to history file */
               xwrite(fn, fh, (char *) &rec, sizeof(rec));
               xwrite(fn, fh, event_name, NAME_LENGTH);
               xwrite(fn, fh, (char *) tag, size);
 
               /* write index record */
               def_rec.event_id = event_id;
               memcpy(def_rec.event_name, event_name, sizeof(event_name));
               def_rec.def_offset = _history[index]->def_offset;
               xwrite(fnd, fhd, (char *) &def_rec, sizeof(def_rec));
            } else
               /* definition identical, just remember old offset */
               _history[index]->def_offset = def_rec.def_offset;
 
            M_FREE(buffer);
         } else {
            /* write definition to history file */
            xwrite(fn, fh, (char *) &rec, sizeof(rec));
            xwrite(fn, fh, event_name, NAME_LENGTH);
            xwrite(fn, fh, (char *) tag, size);
 
            /* write definition index record */
            def_rec.event_id = event_id;
            memcpy(def_rec.event_name, event_name, sizeof(event_name));
            def_rec.def_offset = _history[index]->def_offset;
            xwrite(fn, fhd, (char *) &def_rec, sizeof(def_rec));
         }
      } else {
         fn = _history[index]->hist_fn;
         fnd = _history[index]->def_fn;
         fh = _history[index]->hist_fh;
         fhd = _history[index]->def_fh;
 
         /* compare definition with previous definition */
         buffer = (char *) M_MALLOC(size);
         memset(buffer, 0, size);
 
         xseek(fn, fh, _history[index]->def_offset);
         xread(fn, fh, (char *) &prev_rec, sizeof(prev_rec));
         xread(fn, fh, str, NAME_LENGTH);
         xread(fn, fh, buffer, size);
 
         xseek_end(fn, fh);
         xseek_end(fnd, fhd);
 
         if (prev_rec.data_size != size || strcmp(str, event_name) != 0 || memcmp(buffer, tag, size) != 0) {
            /* save new definition offset */
            DWORD pos = xcurpos(fn, fh);
            if (pos == (DWORD)-1) return HS_FILE_ERROR;
            _history[index]->def_offset = pos;
 
            /* write definition to history file */
            xwrite(fn, fh, (char *) &rec, sizeof(rec));
            xwrite(fn, fh, event_name, NAME_LENGTH);
            xwrite(fn, fh, (char *) tag, size);
 
            /* write index record */
            def_rec.event_id = event_id;
            memcpy(def_rec.event_name, event_name, sizeof(event_name));
            def_rec.def_offset = _history[index]->def_offset;
            xwrite(fnd, fhd, (char *) &def_rec, sizeof(def_rec));
         }
 
         M_FREE(buffer);
      }
 
      ss_semaphore_release(semaphore);
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_define_panel()

INT hs_define_panel	(	const char *	group,
		const char *	panel,
		const std::vector< std::string >	var
	)

Definition at line 3482 of file history.cxx.

{
   HNDLE hDB, hKey, hKeyVar;
   HISTORY_PANEL(history_panel_str);
   char str[256];
 
   const char *color[] = {
           "#00AAFF", "#FF9000", "#FF00A0", "#00C030",
           "#A0C0D0", "#D0A060", "#C04010", "#807060",
           "#F0C000", "#2090A0", "#D040D0", "#90B000",
           "#B0B040", "#B0B0FF", "#FFA0A0", "#A0FFA0",
           "#808080"};
 
   cm_get_experiment_database(&hDB, nullptr);
 
   snprintf(str, sizeof(str), "/History/Display/%s/%s", group, panel);
 
   db_create_record(hDB, 0, str, strcomb1(history_panel_str).c_str());
   db_find_key(hDB, 0, str, &hKey);
   if (!hKey)
      return DB_NO_MEMORY;
 
   int i=0;
   for(auto const& v: var) {
      db_find_key(hDB, hKey, "Variables", &hKeyVar);
      db_set_data_index(hDB, hKeyVar, v.c_str(), 64, i, TID_STRING);
 
      str[0] = 0;
      db_set_value_index(hDB, hKey, "Formula", str, 64, i, TID_STRING, false);
      db_set_value_index(hDB, hKey, "Label", str, 32, i, TID_STRING, false);
      db_set_value_index(hDB, hKey, "Colour", color[i < 16 ? i : 16], 32, i, TID_STRING, false);
 
      i++;
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_define_panel2()

INT hs_define_panel2	(	const char *	group,
		const char *	panel,
		const std::vector< std::string >	var,
		const std::vector< std::string >	label,
		const std::vector< std::string >	formula,
		const std::vector< std::string >	color
	)

Definition at line 3520 of file history.cxx.

{
   HNDLE hDB, hKey, hKeyVar;
   HISTORY_PANEL(history_panel_str);
   char str[256];
 
   const char *default_color[] = {
      "#00AAFF", "#FF9000", "#FF00A0", "#00C030",
      "#A0C0D0", "#D0A060", "#C04010", "#807060",
      "#F0C000", "#2090A0", "#D040D0", "#90B000",
      "#B0B040", "#B0B0FF", "#FFA0A0", "#A0FFA0",
      "#808080"};
 
   cm_get_experiment_database(&hDB, nullptr);
 
   snprintf(str, sizeof(str), "/History/Display/%s/%s", group, panel);
 
   db_create_record(hDB, 0, str, strcomb1(history_panel_str).c_str());
   db_find_key(hDB, 0, str, &hKey);
   if (!hKey)
      return DB_NO_MEMORY;
 
   int i=0;
   for(auto const& v: var) {
      db_find_key(hDB, hKey, "Variables", &hKeyVar);
      db_set_data_index(hDB, hKeyVar, v.c_str(), 64, i, TID_STRING);
 
      if (i < (int)formula.size())
         mstrlcpy(str, formula[i].c_str(), sizeof(str)-1);
      else
         str[0] = 0;
      db_set_value_index(hDB, hKey, "Formula", str, 64, i, TID_STRING, false);
 
      if (i < (int)label.size())
         mstrlcpy(str, label[i].c_str(), sizeof(str)-1);
      else
         str[0] = 0;
      db_set_value_index(hDB, hKey, "Label", str, 32, i, TID_STRING, false);
 
      if (i < (int)color.size())
         mstrlcpy(str, color[i].c_str(), sizeof(str)-1);
      else
         mstrlcpy(str, default_color[i < 16 ? i : 16], sizeof(str)-1);
      db_set_value_index(hDB, hKey, "Colour", str, 32, i, TID_STRING, false);
 
      i++;
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_disconnect()

int MidasHistory::hs_disconnect ( )

inlinevirtual

disconnect from history, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2258 of file history.cxx.

   {
      hs_clear_cache();
      return HS_SUCCESS;
   }

Here is the call graph for this function:

hs_dump()

static INT hs_dump ( DWORD  event_id, DWORD  start_time, DWORD  end_time, DWORD  interval, BOOL  binary_time  )

static

dox Display history for a given event at stdout. The output can be redirected to be read by Excel for example.

Parameters

event_id	Event ID
start_time	Starting Date/Time
end_time	End Date/Time
interval	Minimum time in seconds between reported events. Can be used to skip events
binary_time	Display DWORD time stamp

Returns

HS_SUCCESS, HS_FILE_ERROR

Definition at line 1954 of file history.cxx.

{
   DWORD prev_time, last_irec_time;
   time_t ltime;
   int fh, fhd, fhi;
   std::string fn, fnd, fni;
   INT i, j, delta, status, n_tag = 0, old_n_tag = 0;
   INDEX_RECORD irec;
   HIST_RECORD rec, drec;
   INT old_def_offset, offset;
   TAG *tag = NULL, *old_tag = NULL;
   char data_buffer[10000];
 
   ss_tzset(); // required by localtime_r()
 
   /* if not time given, use present to one hour in past */
   if (start_time == 0)
      start_time = (DWORD) time(NULL) - 3600;
   if (end_time == 0)
      end_time = (DWORD) time(NULL);
 
   /* search history file for start_time */
   status = hs_search_file(&start_time, 1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_dump", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(start_time, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(start_time, "idf", O_RDONLY, &fnd, &fhd);
   hs_open_file(start_time, "idx", O_RDONLY, &fni, &fhi);
   if (fh < 0 || fhd < 0 || fhi < 0) {
      cm_msg(MERROR, "hs_dump", "cannot open index files");
      return HS_FILE_ERROR;
   }
 
   /* search record closest to start time */
   xseek_end(fni, fhi);
   delta = (xcurpos(fni, fhi) / sizeof(irec)) / 2;
   xseek(fni, fhi, delta * sizeof(irec));
   do {
      delta = (int) (abs(delta) / 2.0 + 0.5);
      xread(fni, fhi, (char *) &irec, sizeof(irec));
      if (irec.time > start_time)
         delta = -delta;
 
      xseek_cur(fni, fhi, (delta - 1) * sizeof(irec));
   } while (abs(delta) > 1 && irec.time != start_time);
   xread(fni, fhi, (char *) &irec, sizeof(irec));
   if (irec.time > start_time)
      delta = -abs(delta);
 
   i = xcurpos(fni, fhi) + (delta - 1) * sizeof(irec);
   if (i <= 0)
      xseek(fni, fhi, 0);
   else
      xseek_cur(fni, fhi, (delta - 1) * sizeof(irec));
   xread(fni, fhi, (char *) &irec, sizeof(irec));
 
   /* read records, skip wrong IDs */
   old_def_offset = -1;
   prev_time = 0;
   last_irec_time = 0;
   do {
      if (irec.time < last_irec_time) {
         cm_msg(MERROR, "hs_dump", "corrupted history data: time does not increase: %d -> %d", last_irec_time, irec.time);
         hs_gen_index(last_irec_time);
         return HS_FILE_ERROR;
      }
      last_irec_time = irec.time;
      if (irec.event_id == event_id && irec.time <= end_time && irec.time >= start_time) {
         if (irec.time >= prev_time + interval) {
            prev_time = irec.time;
            xseek(fn, fh, irec.offset);
            xread(fn, fh, (char *) &rec, sizeof(rec));
 
            /* if definition changed, read new definition */
            if ((INT) rec.def_offset != old_def_offset) {
               char buf_name_length[NAME_LENGTH];
               xseek(fn, fh, rec.def_offset);
               xread(fn, fh, (char *) &drec, sizeof(drec));
               xread(fn, fh, buf_name_length, NAME_LENGTH);
 
               if (tag == NULL)
                  tag = (TAG *) M_MALLOC(drec.data_size);
               else
                  tag = (TAG *) realloc(tag, drec.data_size);
               if (tag == NULL)
                  return HS_NO_MEMORY;
               xread(fn, fh, (char *) tag, drec.data_size);
               n_tag = drec.data_size / sizeof(TAG);
 
               /* print tag names if definition has changed */
               if (old_tag == NULL || old_n_tag != n_tag || memcmp(old_tag, tag, drec.data_size) != 0) {
                  printf("Date\t");
                  for (i = 0; i < n_tag; i++) {
                     if (tag[i].n_data == 1 || tag[i].type == TID_STRING)
                        printf("%s\t", tag[i].name);
                     else
                        for (j = 0; j < (INT) tag[i].n_data; j++)
                           printf("%s%d\t", tag[i].name, j);
                  }
                  printf("\n");
 
                  if (old_tag == NULL)
                     old_tag = (TAG *) M_MALLOC(drec.data_size);
                  else
                     old_tag = (TAG *) realloc(old_tag, drec.data_size);
                  memcpy(old_tag, tag, drec.data_size);
                  old_n_tag = n_tag;
               }
 
               old_def_offset = rec.def_offset;
               xseek(fn, fh, irec.offset + sizeof(rec));
            }
 
            /* print time from header */
            if (binary_time)
               printf("%d ", irec.time);
            else {
               ltime = (time_t) irec.time;
               char ctimebuf[32];
               ctime_r(&ltime, ctimebuf);
               char str[256];
               mstrlcpy(str, ctimebuf + 4, sizeof(str));
               str[20] = '\t';
               printf("%s", str);
            }
 
            /* read data */
            xread(fn, fh, data_buffer, rec.data_size);
 
            /* interprete data from tag definition */
            offset = 0;
            for (i = 0; i < n_tag; i++) {
               /* strings have a length of n_data */
               if (tag[i].type == TID_STRING) {
                  printf("%s\t", data_buffer + offset);
                  offset += tag[i].n_data;
               } else if (tag[i].n_data == 1) {
                  /* non-array data */
                  std::string data_str = db_sprintf(data_buffer + offset, rpc_tid_size(tag[i].type), 0, tag[i].type);
                  printf("%s\t", data_str.c_str());
                  offset += rpc_tid_size(tag[i].type);
               } else
                  /* loop over array data */
                  for (j = 0; j < (INT) tag[i].n_data; j++) {
                     std::string data_str = db_sprintf(data_buffer + offset, rpc_tid_size(tag[i].type), 0, tag[i].type);
                     printf("%s\t", data_str.c_str());
                     offset += rpc_tid_size(tag[i].type);
                  }
            }
            printf("\n");
         }
      }
 
      /* read next index record */
      i = xread(fni, fhi, (char *) &irec, sizeof(irec), true);
 
      /* end of file: search next history file */
      if (i <= 0) {
         close(fh);
         close(fhd);
         close(fhi);
 
         /* advance one day */
         ltime = (time_t) last_irec_time;
         struct tm tms;
         localtime_r(&ltime, &tms);
         tms.tm_hour = tms.tm_min = tms.tm_sec = 0;
         last_irec_time = (DWORD) ss_mktime(&tms);
 
         last_irec_time += 3600 * 24;
         if (last_irec_time > end_time)
            break;
 
         /* search next file */
         status = hs_search_file((DWORD *) & last_irec_time, 1);
         if (status != HS_SUCCESS)
            break;
 
         /* open history and definition files */
         hs_open_file(last_irec_time, "hst", O_RDONLY, &fn, &fh);
         hs_open_file(last_irec_time, "idf", O_RDONLY, &fnd, &fhd);
         hs_open_file(last_irec_time, "idx", O_RDONLY, &fni, &fhi);
         if (fh < 0 || fhd < 0 || fhi < 0) {
            cm_msg(MERROR, "hs_dump", "cannot open index files");
            break;
         }
 
         /* read first record */
         i = xread(fni, fhi, (char *) &irec, sizeof(irec), true);
         if (i <= 0)
            break;
 
         /* old definition becomes invalid */
         old_def_offset = -1;
      }
   } while (irec.time < end_time);
 
   M_FREE(tag);
   M_FREE(old_tag);
   close(fh);
   close(fhd);
   close(fhi);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_enum_events()

static INT hs_enum_events ( DWORD  ltime, char *  event_name, DWORD *  name_size, INT  event_id[], DWORD *  id_size  )

static

Definition at line 823 of file history.cxx.

{
   int fh, fhd;
   std::string fn, fnd;
   INT status, i, n;
   DEF_RECORD def_rec;
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_enum_events", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_enum_events", "cannot open index files");
      return HS_FILE_ERROR;
   }
   xseek(fnd, fhd, 0);
 
   /* loop over definition index file */
   n = 0;
   do {
      /* read event definition */
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec), true) <= 0)
         break;
 
      /* look for existing entry for this event id */
      for (i = 0; i < n; i++)
         if (event_id[i] == (INT) def_rec.event_id) {
            strcpy(event_name + i * NAME_LENGTH, def_rec.event_name);
            break;
         }
 
      /* new entry found */
      if (i == n) {
         if (((i * NAME_LENGTH) > ((INT) * name_size)) || ((i * sizeof(INT)) > (*id_size))) {
            cm_msg(MERROR, "hs_enum_events", "index buffer too small");
            close(fh);
            close(fhd);
            return HS_NO_MEMORY;
         }
 
         /* copy definition record */
         strcpy(event_name + i * NAME_LENGTH, def_rec.event_name);
         event_id[i] = def_rec.event_id;
         n++;
      }
   } while (TRUE);
 
   close(fh);
   close(fhd);
   *name_size = n * NAME_LENGTH;
   *id_size = n * sizeof(INT);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_enum_vars()

static INT hs_enum_vars ( DWORD  ltime, DWORD  event_id, char *  var_name, DWORD *  size, DWORD *  var_n, DWORD *  n_size  )

static

Definition at line 1128 of file history.cxx.

{
   char str[256];
   int fh, fhd;
   std::string fn, fnd;
   INT i, n, status;
   DEF_RECORD def_rec;
   HIST_RECORD rec;
   TAG *tag;
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_enum_vars", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_enum_vars", "cannot open index files");
      return HS_FILE_ERROR;
   }
 
   /* search last definition */
   xseek_end(fnd, fhd);
   n = xcurpos(fnd, fhd) / sizeof(def_rec);
   def_rec.event_id = 0;
   for (i = n - 1; i >= 0; i--) {
      if (!xseek(fnd, fhd, i * sizeof(def_rec))) return HS_FILE_ERROR;
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec)) < 0) return HS_FILE_ERROR;
      if (def_rec.event_id == event_id)
         break;
   }
   if (def_rec.event_id != event_id) {
      cm_msg(MERROR, "hs_enum_vars", "event %d not found in index file", event_id);
      return HS_FILE_ERROR;
   }
 
   /* read definition header */
   xseek(fn, fh, def_rec.def_offset);
   xread(fn, fh, (char *) &rec, sizeof(rec));
   xread(fn, fh, str, NAME_LENGTH);
 
   /* read event definition */
   n = rec.data_size / sizeof(TAG);
   tag = (TAG *) M_MALLOC(rec.data_size);
   xread(fn, fh, (char *) tag, rec.data_size);
 
   if (n * NAME_LENGTH > (INT) * size || n * sizeof(DWORD) > *n_size) {
 
      /* store partial definition */
      for (i = 0; i < (INT) * size / NAME_LENGTH; i++) {
         strcpy(var_name + i * NAME_LENGTH, tag[i].name);
         var_n[i] = tag[i].n_data;
      }
 
      cm_msg(MERROR, "hs_enum_vars", "tag buffer too small");
      M_FREE(tag);
      close(fh);
      close(fhd);
      return HS_NO_MEMORY;
   }
 
   /* store full definition */
   for (i = 0; i < n; i++) {
      strcpy(var_name + i * NAME_LENGTH, tag[i].name);
      var_n[i] = tag[i].n_data;
   }
   *size = n * NAME_LENGTH;
   *n_size = n * sizeof(DWORD);
 
   M_FREE(tag);
   close(fh);
   close(fhd);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_flush_buffers()

int MidasHistory::hs_flush_buffers ( )

inlinevirtual

flush buffered data to storage where it is visible to mhttpd

Implements MidasHistoryInterface.

Definition at line 2645 of file history.cxx.

   {
      //printf("hs_flush_buffers!\n");
      return HS_SUCCESS;
   }

hs_gen_index()

static INT hs_gen_index ( DWORD  ltime )

static

Definition at line 237 of file history.cxx.

{
   char event_name[NAME_LENGTH];
   int fh, fhd, fhi;
   HIST_RECORD rec;
   INDEX_RECORD irec;
   DEF_RECORD def_rec;
   int recovering = 0;
   //time_t now = time(NULL);
 
   cm_msg(MINFO, "hs_gen_index", "generating index files for time %d", (int) ltime);
   printf("Recovering index files...\n");
 
   if (ltime == 0)
      ltime = (DWORD) time(NULL);
 
   std::string fni;
   std::string fnd;
   std::string fn;
 
   /* open new index file */
   hs_open_file(ltime, "idx", O_RDWR | O_CREAT | O_TRUNC, &fni, &fhi);
   hs_open_file(ltime, "idf", O_RDWR | O_CREAT | O_TRUNC, &fnd, &fhd);
 
   if (fhd < 0 || fhi < 0) {
      cm_msg(MERROR, "hs_gen_index", "cannot create index file");
      return HS_FILE_ERROR;
   }
 
   /* open history file */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   if (fh < 0)
      return HS_FILE_ERROR;
   xseek(fn, fh, 0);
 
   /* loop over file records in .hst file */
   do {
      if (xread(fn, fh, (char *) &rec, sizeof(rec), true) <= 0) {
         break;
      }
 
      /* check if record type is definition */
      if (rec.record_type == RT_DEF) {
         /* read name */
         if (xread(fn, fh, event_name, sizeof(event_name)) < 0)
            return HS_FILE_ERROR;
 
         printf("Event definition %s, ID %d\n", event_name, rec.event_id);
 
         /* write definition index record */
         def_rec.event_id = rec.event_id;
         memcpy(def_rec.event_name, event_name, sizeof(event_name));
         DWORD pos = xcurpos(fn, fh);
         if (pos == (DWORD)-1) return HS_FILE_ERROR;
         def_rec.def_offset = pos - sizeof(event_name) - sizeof(rec);
         xwrite(fnd, fhd, (char *) &def_rec, sizeof(def_rec));
 
         //printf("data def at %d (age %d)\n", rec.time, now-rec.time);
 
         /* skip tags */
         xseek_cur(fn, fh, rec.data_size);
      } else if (rec.record_type == RT_DATA && rec.data_size > 1 && rec.data_size < 1 * 1024 * 1024) {
         /* write index record */
         irec.event_id = rec.event_id;
         irec.time = rec.time;
         DWORD pos = xcurpos(fn, fh);
         if (pos == (DWORD)-1) return HS_FILE_ERROR;
         irec.offset = pos - sizeof(rec);
         xwrite(fni, fhi, (char *) &irec, sizeof(irec));
 
         //printf("data rec at %d (age %d)\n", rec.time, now-rec.time);
 
         /* skip data */
         xseek_cur(fn, fh, rec.data_size);
      } else {
         if (!recovering)
            cm_msg(MERROR, "hs_gen_index", "broken history file for time %d, trying to recover", (int) ltime);
 
         recovering = 1;
         xseek_cur(fn, fh, 1 - (int)sizeof(rec));
 
         continue;
      }
 
   } while (TRUE);
 
   close(fh);
   close(fhi);
   close(fhd);
 
   printf("...done.\n");
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_get_event_id()

static INT hs_get_event_id ( DWORD  ltime, const char *  name, DWORD *  id  )

static

Definition at line 984 of file history.cxx.

{
   int fh, fhd;
   std::string fn, fnd;
   INT status;
   DWORD lt;
   DEF_RECORD def_rec;
 
   /* search latest history file */
   if (ltime == 0)
      ltime = (DWORD) time(NULL);
 
   lt = ltime;
 
   do {
      status = hs_search_file(&lt, -1);
      if (status != HS_SUCCESS) {
         cm_msg(MERROR, "hs_count_events", "cannot find recent history file");
         return HS_FILE_ERROR;
      }
 
      /* open history and definition files */
      hs_open_file(lt, "hst", O_RDONLY, &fn, &fh);
      hs_open_file(lt, "idf", O_RDONLY, &fnd, &fhd);
      if (fh < 0 || fhd < 0) {
         cm_msg(MERROR, "hs_count_events", "cannot open index files");
         return HS_FILE_ERROR;
      }
 
      /* loop over index file */
      *id = 0;
      do {
         /* read definition index record */
         if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec), true) <= 0)
            break;
 
         if (strcmp(name, def_rec.event_name) == 0) {
            *id = def_rec.event_id;
            close(fh);
            close(fhd);
            return HS_SUCCESS;
         }
      } while (TRUE);
 
      close(fh);
      close(fhd);
 
      /* not found -> go back one day */
      lt -= 3600 * 24;
 
   } while (lt > ltime - 3600 * 24 * 365 * 10); /* maximum 10 years */
 
   return HS_UNDEFINED_EVENT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_get_events()

int MidasHistory::hs_get_events ( time_t  time_from, std::vector< std::string > *  pevents  )

inlinevirtual

get list of events that exist(ed) at given time and later (value 0 means "return all events from beginning of time"), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 2768 of file history.cxx.

   {
      assert(pevents);
      pevents->clear();
 
      if (fEventsCache.size() == 0) {
         int status;
 
         if (fDebug)
            printf("hs_get_events: reading events list!\n");
         
         status = GetEventsFromOdbTags(&fEventsCache);
 
         if (status != HS_SUCCESS)
            status = GetEventsFromOdbEvents(&fEventsCache);
 
         if (status != HS_SUCCESS)
            return status;
      }
 
      for (unsigned i=0; i<fEventsCache.size(); i++)
         pevents->push_back(fEventsCache[i]);
         
      return HS_SUCCESS;
   }

Here is the call graph for this function:

hs_get_last_written()

int MidasHistory::hs_get_last_written ( time_t  start_time, int  num_var, const char *const  event_name[], const char *const  tag_name[], const int  var_index[], time_t  last_written[]  )

inlinevirtual

Implements MidasHistoryInterface.

Definition at line 3168 of file history.cxx.

   {
      for (int i=0; i<num_var; i++)
         last_written[i] = 0;
      return HS_FILE_ERROR;
   }

hs_get_tags() [1/2]

int MidasHistory::hs_get_tags ( const char *  event_name, time_t  time_from, std::vector< TAG > *  ptags  )

inlinevirtual

get list of history variables for given event (use event names returned by hs_get_events()) that exist(ed) at given time and later (value 0 means "all variables for this event that ever existed"), also see hs_get_tags(), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3141 of file history.cxx.

   {
      std::vector<TAG>& ttt = fTagsCache[event_name];
 
      if (ttt.size() == 0) {
         int status = HS_FILE_ERROR;
 
         if (fDebug)
            printf("hs_get_tags: reading tags for event [%s]\n", event_name);
 
         status = GetTagsFromOdb(event_name, &ttt);
 
         if (status != HS_SUCCESS)
            status = GetTagsFromHS(event_name, &ttt);
 
         if (status != HS_SUCCESS)
            return status;
      }
 
      for (unsigned i=0; i<ttt.size(); i++)
         ptags->push_back(ttt[i]);
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hs_get_tags() [2/2]

static INT hs_get_tags ( DWORD  ltime, DWORD  event_id, char  event_name[NAME_LENGTH], int *  n_tags, TAG **  tags  )

static

Definition at line 1328 of file history.cxx.

{
   int fh, fhd;
   std::string fn, fnd;
   INT i, n, status;
   DEF_RECORD def_rec;
   HIST_RECORD rec;
 
   *n_tags = 0;
   *tags = NULL;
 
   if (rpc_is_remote())
      assert(!"RPC not implemented");
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_get_tags", "cannot find recent history file, hs_search_file() status %d", status);
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_get_tags", "cannot open index files for time %d", ltime);
      if (fh>0)
         close(fh);
      if (fhd>0)
         close(fhd);
      return HS_FILE_ERROR;
   }
 
   /* search last definition */
   xseek_end(fnd, fhd);
   n = xcurpos(fnd, fhd) / sizeof(def_rec);
   def_rec.event_id = 0;
   for (i = n - 1; i >= 0; i--) {
      if (!xseek(fnd, fhd, i * sizeof(def_rec))) return HS_FILE_ERROR;
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec)) < 0) return HS_FILE_ERROR;
      //printf("reading index file found event_id %d, looking for %d\n", def_rec.event_id, event_id);
      if (def_rec.event_id == event_id)
         break;
   }
 
   if (def_rec.event_id != event_id) {
      //cm_msg(MERROR, "hs_get_tags", "event %d not found in index file", event_id);
      close(fh);
      close(fhd);
      return HS_UNDEFINED_EVENT;
   }
 
   /* read definition header */
   if (!xseek(fn, fh, def_rec.def_offset)) return HS_FILE_ERROR;
   if (xread(fn, fh, (char *) &rec, sizeof(rec)) < 0) return HS_FILE_ERROR;
   if (xread(fn, fh, event_name, NAME_LENGTH) < 0)    return HS_FILE_ERROR;
 
   /* read event definition */
   *n_tags = rec.data_size / sizeof(TAG);
 
   *tags = (TAG*) malloc(rec.data_size);
 
   if (xread(fn, fh, (char *) (*tags), rec.data_size) < 0) return HS_FILE_ERROR;
 
   close(fh);
   close(fhd);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_get_var()

static INT hs_get_var ( DWORD  ltime, DWORD  event_id, const char *  var_name, DWORD *  type, INT *  n_data  )

static

Definition at line 1232 of file history.cxx.

{
   char str[256];
   int fh, fhd;
   std::string fn, fnd;
   INT i, n, status;
   DEF_RECORD def_rec;
   HIST_RECORD rec;
   TAG *tag;
 
   /* search latest history file */
   status = hs_search_file(&ltime, -1);
   if (status != HS_SUCCESS) {
      cm_msg(MERROR, "hs_get_var", "cannot find recent history file");
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(ltime, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(ltime, "idf", O_RDONLY, &fnd, &fhd);
   if (fh < 0 || fhd < 0) {
      cm_msg(MERROR, "hs_get_var", "cannot open index files");
      return HS_FILE_ERROR;
   }
 
   /* search last definition */
   xseek_end(fnd, fhd);
   n = xcurpos(fnd, fhd) / sizeof(def_rec);
   def_rec.event_id = 0;
   for (i = n - 1; i >= 0; i--) {
      if (!xseek(fnd, fhd, i * sizeof(def_rec))) return HS_FILE_ERROR;
      if (xread(fnd, fhd, (char *) &def_rec, sizeof(def_rec)) < 0) return HS_FILE_ERROR;
      if (def_rec.event_id == event_id)
         break;
   }
   if (def_rec.event_id != event_id) {
      cm_msg(MERROR, "hs_get_var", "event %d not found in index file", event_id);
      return HS_FILE_ERROR;
   }
 
   /* read definition header */
   xseek(fn, fh, def_rec.def_offset);
   xread(fn, fh, (char *) &rec, sizeof(rec));
   xread(fn, fh, str, NAME_LENGTH);
 
   /* read event definition */
   n = rec.data_size / sizeof(TAG);
   tag = (TAG *) M_MALLOC(rec.data_size);
   xread(fn, fh, (char *) tag, rec.data_size);
 
   /* search variable */
   for (i = 0; i < n; i++)
      if (strcmp(tag[i].name, var_name) == 0)
         break;
 
   close(fh);
   close(fhd);
 
   if (i < n) {
      *type = tag[i].type;
      *n_data = tag[i].n_data;
   } else {
      *type = *n_data = 0;
      cm_msg(MERROR, "hs_get_var", "variable %s not found", var_name);
      M_FREE(tag);
      return HS_UNDEFINED_VAR;
   }
 
   M_FREE(tag);
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_open_file()

static INT hs_open_file ( time_t  ltime, const char *  suffix, INT  mode, std::string *  pfile_name, int *  fh  )

static

dox Open history file belonging to certain date. Internal use only.

Parameters

ltime	Date for which a history file should be opened.
suffix	File name suffix like "hst", "idx", "idf"
mode	R/W access mode
fh	File handle

Returns

HS_SUCCESS

Definition at line 206 of file history.cxx.

{
   struct tm tms;
   time_t ttime;
 
   /* generate new file name YYMMDD.xxx */
   ss_tzset(); // required by localtime_r()
   ttime = (time_t) ltime;
   localtime_r(&ttime, &tms);
 
   //sprintf(file_name, "%s%02d%02d%02d.%s", _hs_path_name, tms.tm_year % 100, tms.tm_mon + 1, tms.tm_mday, suffix);
   std::string file_name;
   file_name += _hs_path_name;
   char tmp[100];
   sprintf(tmp, "%02d%02d%02d", tms.tm_year % 100, tms.tm_mon + 1, tms.tm_mday);
   file_name += tmp;
   file_name += ".";
   file_name += suffix;
 
   if (pfile_name)
      *pfile_name = file_name;
 
   /* open file, add O_BINARY flag for Windows NT */
   *fh = open(file_name.c_str(), mode | O_BINARY, 0644);
 
   //printf("hs_open_file: time %d, file \'%s\', fh %d\n", (int)ltime, file_name.c_str(), *fh);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_read() [1/2]

static INT hs_read ( DWORD  event_id, DWORD  start_time, DWORD  end_time, DWORD  interval, const char *  tag_name, DWORD  var_index, DWORD *  time_buffer, DWORD *  tbsize, void *  data_buffer, DWORD *  dbsize, DWORD *  data_type, DWORD *  data_n, MidasHistoryBufferInterface *  buffer  )

static

Definition at line 1451 of file history.cxx.

{
   DWORD prev_time, last_irec_time;
   int fh, fhd, fhi, cp = 0;
   std::string fn, fnd, fni;
   int delta;
   int status;
   int cache_size;
   INDEX_RECORD irec, *pirec;
   HIST_RECORD rec, drec;
   INT old_def_offset;
   TAG *tag;
   char str[NAME_LENGTH];
   char *cache = NULL;
   time_t ltime;
 
   int tag_index = -1;
   int var_type = -1;
   unsigned var_size = 0;
   unsigned var_offset = 0;
         
   int ieof = 0;
 
   //printf("hs_read event %d, time %d:%d, tagname: \'%s\', varindex: %d\n", event_id, start_time, end_time, tag_name, var_index);
 
   ss_tzset(); // required by localtime_r()
 
   /* if not time given, use present to one hour in past */
   if (start_time == 0)
      start_time = (DWORD) time(NULL) - 3600;
   if (end_time == 0)
      end_time = (DWORD) time(NULL);
 
   if (data_n)
      *data_n = 0;
   prev_time = 0;
   last_irec_time = start_time;
 
   /* search history file for start_time */
   status = hs_search_file(&start_time, 1);
   if (status != HS_SUCCESS) {
      //cm_msg(MERROR, "hs_read", "cannot find recent history file");
      if (data_n)
         *data_n = 0;
      if (tbsize)
         *tbsize = 0;
      if (dbsize)
         *dbsize = 0;
      return HS_FILE_ERROR;
   }
 
   /* open history and definition files */
   hs_open_file(start_time, "hst", O_RDONLY, &fn, &fh);
   hs_open_file(start_time, "idf", O_RDONLY, &fnd, &fhd);
   hs_open_file(start_time, "idx", O_RDONLY, &fni, &fhi);
   if (fh < 0 || fhd < 0 || fhi < 0) {
      cm_msg(MERROR, "hs_read", "cannot open index files");
      if (tbsize)
         *tbsize = 0;
      if (dbsize)
         *dbsize = 0;
      if (data_n)
         *data_n = 0;
      if (fh > 0)
         close(fh);
      if (fhd > 0)
         close(fhd);
      if (fhi > 0)
         close(fhi);
      return HS_FILE_ERROR;
   }
 
   /* try to read index file into cache */
   xseek_end(fni, fhi);
   cache_size = xcurpos(fni, fhi);
 
   if (cache_size == 0) {
      goto nextday;
   }
 
   if (cache_size > 0) {
      cache = (char *) M_MALLOC(cache_size);
      if (cache) {
         xseek(fni, fhi, 0);
         if (xread(fni, fhi, cache, cache_size) < 0) {
            M_FREE(cache);
            if (fh > 0)
               close(fh);
            if (fhd > 0)
               close(fhd);
            if (fhi > 0)
               close(fhi);
            return HS_FILE_ERROR;
         }
      }
 
      /* search record closest to start time */
      if (cache == NULL) {
         xseek_end(fni, fhi);
         delta = (xcurpos(fni, fhi) / sizeof(irec)) / 2;
         xseek(fni, fhi, delta * sizeof(irec));
         do {
            delta = (int) (abs(delta) / 2.0 + 0.5);
            if (xread(fni, fhi, (char *) &irec, sizeof(irec)) < 0)
               return HS_FILE_ERROR;
            if (irec.time > start_time)
               delta = -delta;
 
            xseek_cur(fni, fhi, (delta - 1) * sizeof(irec));
         } while (abs(delta) > 1 && irec.time != start_time);
         if (xread(fni, fhi, (char *) &irec, sizeof(irec)) < 0)
            return HS_FILE_ERROR;
         if (irec.time > start_time)
            delta = -abs(delta);
 
         int i = xcurpos(fni, fhi) + (delta - 1) * sizeof(irec);
         if (i <= 0)
            xseek(fni, fhi, 0);
         else
            xseek_cur(fni, fhi, (delta - 1) * sizeof(irec));
         if (xread(fni, fhi, (char *) &irec, sizeof(irec)) < 0)
            return HS_FILE_ERROR;
      } else {
         delta = (cache_size / sizeof(irec)) / 2;
         cp = delta * sizeof(irec);
         do {
            delta = (int) (abs(delta) / 2.0 + 0.5);
            pirec = (INDEX_RECORD *) (cache + cp);
 
            //printf("pirec %p, cache %p, cp %d\n", pirec, cache, cp);
 
            if (pirec->time > start_time)
               delta = -delta;
 
            cp = cp + delta * sizeof(irec);
 
            if (cp < 0)
               cp = 0;
            if (cp >= cache_size)
               cp = cache_size - sizeof(irec);
         } while (abs(delta) > 1 && pirec->time != start_time);
         pirec = (INDEX_RECORD *) (cache + cp);
         if (pirec->time > start_time)
            delta = -abs(delta);
 
         if (cp <= delta * (int) sizeof(irec))
            cp = 0;
         else
            cp = cp + delta * sizeof(irec);
 
         if (cp >= cache_size)
            cp = cache_size - sizeof(irec);
         if (cp < 0)
            cp = 0;
 
         memcpy(&irec, (INDEX_RECORD *) (cache + cp), sizeof(irec));
         cp += sizeof(irec);
      }
   } else {                     /* file size > 0 */
 
      cache = NULL;
      irec.time = start_time;
   }
 
   /* read records, skip wrong IDs */
   old_def_offset = -1;
   last_irec_time = start_time - 24 * 60 * 60;
   do {
      //printf("time %d -> %d\n", last_irec_time, irec.time);
 
      if (irec.time < last_irec_time) {
         cm_msg(MERROR, "hs_read", "corrupted history data: time does not increase: %d -> %d", last_irec_time, irec.time);
         //*tbsize = *dbsize = *n = 0;
         if (fh > 0)
            close(fh);
         if (fhd > 0)
            close(fhd);
         if (fhi > 0)
            close(fhi);
         hs_gen_index(last_irec_time);
         return HS_SUCCESS;
      }
      last_irec_time = irec.time;
      if (irec.event_id == event_id && irec.time <= end_time && irec.time >= start_time) {
         /* check if record time more than "interval" seconds after previous time */
         if (irec.time >= prev_time + interval) {
            prev_time = irec.time;
            xseek(fn, fh, irec.offset);
            if (xread(fn, fh, (char *) &rec, sizeof(rec)) < 0) {
               cm_msg(MERROR, "hs_read", "corrupted history data at time %d", (int) irec.time);
               //*tbsize = *dbsize = *n = 0;
               if (fh > 0)
                  close(fh);
               if (fhd > 0)
                  close(fhd);
               if (fhi > 0)
                  close(fhi);
               hs_gen_index(last_irec_time);
               return HS_SUCCESS;
            }
 
            /* if definition changed, read new definition */
            if ((INT) rec.def_offset != old_def_offset) {
               xseek(fn, fh, rec.def_offset);
               xread(fn, fh, (char *) &drec, sizeof(drec));
               xread(fn, fh, str, NAME_LENGTH);
 
               tag = (TAG *) M_MALLOC(drec.data_size);
               if (tag == NULL) {
                  if (data_n)
                     *data_n = 0;
                  if (tbsize)
                     *tbsize = 0;
                  if (dbsize)
                     *dbsize = 0;
                  if (cache)
                     M_FREE(cache);
                  if (fh > 0)
                     close(fh);
                  if (fhd > 0)
                     close(fhd);
                  if (fhi > 0)
                     close(fhi);
                  return HS_NO_MEMORY;
               }
               xread(fn, fh, (char *) tag, drec.data_size);
 
               /* find index of tag_name in new definition */
               for (DWORD i = 0; i < drec.data_size / sizeof(TAG); i++)
                  if (equal_ustring(tag[i].name, tag_name)) {
                     tag_index = i;
                     break;
                  }
 
               /*
                  if ((DWORD) i == drec.data_size/sizeof(TAG))
                  {
                  *n = *tbsize = *dbsize = 0;
                  if (cache)
                  M_FREE(cache);
 
                  return HS_UNDEFINED_VAR;
                  }
                */
 
               if (tag_index >= 0 && var_index >= tag[tag_index].n_data) {
                  if (data_n)
                     *data_n = 0;
                  if (tbsize)
                     *tbsize = 0;
                  if (dbsize)
                     *dbsize = 0;
                  if (cache)
                     M_FREE(cache);
                  M_FREE(tag);
                  if (fh > 0)
                     close(fh);
                  if (fhd > 0)
                     close(fhd);
                  if (fhi > 0)
                     close(fhi);
                  return HS_WRONG_INDEX;
               }
 
               /* calculate offset for variable */
               if (tag_index >= 0) {
                  var_type = tag[tag_index].type;
 
                  if (data_type)
                     *data_type = var_type;
 
                  /* loop over all previous variables */
                  var_offset = 0;
                  for (int i=0; i<tag_index; i++)
                     var_offset += rpc_tid_size(tag[i].type) * tag[i].n_data;
 
                  /* strings have size n_data */
                  if (tag[tag_index].type == TID_STRING)
                     var_size = tag[tag_index].n_data;
                  else
                     var_size = rpc_tid_size(tag[tag_index].type);
 
                  var_offset += var_size * var_index;
               }
 
               M_FREE(tag);
               old_def_offset = rec.def_offset;
               xseek(fn, fh, irec.offset + sizeof(rec));
            }
 
            if (buffer) {
               /* copy time from header */
               DWORD t = irec.time;
               char buf[16]; // biggest data is 8-byte "double"
               assert(var_size <= sizeof(buf));
               xseek_cur(fn, fh, var_offset);
               xread(fn, fh, buf, var_size);
               buffer->Add(t, hs_to_double(var_type, buf));
            } else if (tag_index >= 0 && data_n) {
               /* check if data fits in buffers */
               if ((*data_n) * sizeof(DWORD) >= *tbsize || (*data_n) * var_size >= *dbsize) {
                  *dbsize = (*data_n) * var_size;
                  *tbsize = (*data_n) * sizeof(DWORD);
                  if (cache)
                     M_FREE(cache);
                  if (fh > 0)
                     close(fh);
                  if (fhd > 0)
                     close(fhd);
                  if (fhi > 0)
                     close(fhi);
                  return HS_TRUNCATED;
               }
 
               /* copy time from header */
               time_buffer[*data_n] = irec.time;
 
               /* copy data from record */
               xseek_cur(fn, fh, var_offset);
               xread(fn, fh, (char *) data_buffer + (*data_n) * var_size, var_size);
 
               /* increment counter */
               (*data_n)++;
            }
         }
      }
         
      /* read next index record */
      if (cache) {
         if (cp >= cache_size) {
            ieof = -1;
            M_FREE(cache);
            cache = NULL;
         } else {
 
          try_again:
 
            ieof = sizeof(irec);
 
            memcpy(&irec, cache + cp, sizeof(irec));
            cp += sizeof(irec);
 
            /* if history file is broken ... */
            if (irec.time < last_irec_time || irec.time > last_irec_time + 24 * 60 * 60) {
               //if (irec.time < last_irec_time) {
               //printf("time %d -> %d, cache_size %d, cp %d\n", last_irec_time, irec.time, cache_size, cp);
 
               //printf("Seeking next record...\n");
 
               while (cp < cache_size) {
                  DWORD *evidp = (DWORD *) (cache + cp);
                  if (*evidp == event_id) {
                     //printf("Found at cp %d\n", cp);
                     goto try_again;
                  }
 
                  cp++;
               }
 
               ieof = -1;
            }
         }
      } else {
         ieof = xread(fni, fhi, (char *) &irec, sizeof(irec), true);
      }
 
      /* end of file: search next history file */
      if (ieof <= 0) {
         nextday:
 
         if (fh > 0)
            close(fh);
         if (fhd > 0)
            close(fhd);
         if (fhi > 0)
            close(fhi);
         fh = fhd = fhi = 0;
 
         /* advance one day */
         ltime = (time_t) last_irec_time;
         struct tm tms;
         localtime_r(&ltime, &tms);
         tms.tm_hour = tms.tm_min = tms.tm_sec = 0;
         last_irec_time = (DWORD) ss_mktime(&tms);
 
         last_irec_time += 3600 * 24;
 
         if (last_irec_time > end_time)
            break;
 
         /* search next file */
         status = hs_search_file(&last_irec_time, 1);
         if (status != HS_SUCCESS)
            break;
 
         /* open history and definition files */
         hs_open_file(last_irec_time, "hst", O_RDONLY, &fn, &fh);
         hs_open_file(last_irec_time, "idf", O_RDONLY, &fnd, &fhd);
         hs_open_file(last_irec_time, "idx", O_RDONLY, &fni, &fhi);
         if (fh < 0 || fhd < 0 || fhi < 0) {
            cm_msg(MERROR, "hs_read", "cannot open index files");
            break;
         }
 
         /* try to read index file into cache */
         xseek_end(fni, fhi);
         cache_size = xcurpos(fni, fhi);
 
         if (cache_size == 0) {
            goto nextday;
         }
 
         xseek(fni, fhi, 0);
         cache = (char *) M_MALLOC(cache_size); // FIXME: is this a memory leak?
         if (cache) {
            if (xread(fni, fhi, cache, cache_size) < 0) {
               break;
            }
            /* read first record */
            cp = 0;
            memcpy(&irec, cache, sizeof(irec));
         } else {
            /* read first record */
            if (xread(fni, fhi, (char *) &irec, sizeof(irec)) < 0) {
               break;
            }
         }
 
         /* old definition becomes invalid */
         old_def_offset = -1;
      }
      //if (event_id==4 && irec.event_id == event_id)
      //  printf("time %d end %d\n", irec.time, end_time);
   } while (irec.time < end_time);
 
   if (cache)
      M_FREE(cache);
   if (fh)
      close(fh);
   if (fhd)
      close(fhd);
   if (fhi)
      close(fhi);
 
   if (dbsize && data_n)
      *dbsize = *data_n * var_size;
   if (tbsize && data_n)
      *tbsize = *data_n * sizeof(DWORD);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_read() [2/2]

int MidasHistory::hs_read ( time_t  start_time, time_t  end_time, time_t  interval, int  num_var, const char *const  event_name[], const char *const  tag_name[], const int  var_index[], int  num_entries[], time_t *  time_buffer[], double *  data_buffer[], int  status[]  )

inlinevirtual

see hs_read(), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3178 of file history.cxx.

   {
      DWORD* tbuffer = NULL;
      char* ybuffer = NULL;
      DWORD bsize, tsize;
      int hbuffer_size = 0;
      
      if (hbuffer_size == 0) {
         hbuffer_size = 1000 * sizeof(DWORD);
         tbuffer = (DWORD*)malloc(hbuffer_size);
         ybuffer = (char*)malloc(hbuffer_size);
      }
 
      for (int i=0; i<num_var; i++) {
         DWORD tid = 0;
         int event_id = 0;
 
         if (event_name[i]==NULL) {
            read_status[i] = HS_UNDEFINED_EVENT;
            num_entries[i] = 0;
            continue;
         }
         
         int status = GetEventId(end_time, event_name[i], tag_name[i], &event_id);
         
         if (status != HS_SUCCESS) {
            read_status[i] = status;
            continue;
         }
         
         DWORD n_point = 0;
         
         do {
            bsize = tsize = hbuffer_size;
            memset(ybuffer, 0, bsize);
            status = ::hs_read(event_id, (DWORD)start_time, (DWORD)end_time, (DWORD)interval,
                               tag_name[i], var_index[i],
                               tbuffer, &tsize,
                               ybuffer, &bsize,
                               &tid, &n_point,
                               NULL);
         
            if (fDebug)
               printf("hs_read %d \'%s\' [%d] returned %d, %d entries\n", event_id, tag_name[i], var_index[i], status, n_point);
         
            if (status == HS_TRUNCATED) {
               hbuffer_size *= 2;
               tbuffer = (DWORD*)realloc(tbuffer, hbuffer_size);
               assert(tbuffer);
               ybuffer = (char*)realloc(ybuffer, hbuffer_size);
               assert(ybuffer);
            }
 
         } while (status == HS_TRUNCATED);
        
         read_status[i] = status;
 
         time_t* x = (time_t*)malloc(n_point*sizeof(time_t));
         assert(x);
         double* y = (double*)malloc(n_point*sizeof(double));
         assert(y);
 
         time_buffer[i] = x;
         data_buffer[i] = y;
 
         int n_vp = 0;
 
         for (unsigned j = 0; j < n_point; j++) {
            x[n_vp] = tbuffer[j];
          
            /* convert data to float */
            switch (tid) {
            default:
               y[n_vp] =  0;
               break;
            case TID_BYTE:
               y[n_vp] =  *(((BYTE *) ybuffer) + j);
               break;
            case TID_SBYTE:
               y[n_vp] =  *(((char *) ybuffer) + j);
               break;
            case TID_CHAR:
               y[n_vp] =  *(((char *) ybuffer) + j);
               break;
            case TID_WORD:
               y[n_vp] =  *(((WORD *) ybuffer) + j);
               break;
            case TID_SHORT:
               y[n_vp] =  *(((short *) ybuffer) + j);
               break;
            case TID_DWORD:
               y[n_vp] =  *(((DWORD *) ybuffer) + j);
               break;
            case TID_INT:
               y[n_vp] =  *(((INT *) ybuffer) + j);
               break;
            case TID_BOOL:
               y[n_vp] =  *(((BOOL *) ybuffer) + j);
               break;
            case TID_FLOAT:
               y[n_vp] =  *(((float *) ybuffer) + j);
               break;
            case TID_DOUBLE:
               y[n_vp] =  *(((double *) ybuffer) + j);
               break;
            }
          
            n_vp++;
         }
 
         num_entries[i] = n_vp;
      }
 
      if (ybuffer)
         free(ybuffer);
      if (tbuffer)
         free(tbuffer);
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hs_read_binned()

int MidasHistory::hs_read_binned ( time_t  start_time, time_t  end_time, int  num_bins, int  num_var, const char *const  event_name[], const char *const  tag_name[], const int  var_index[], int  num_entries[], int *  count_bins[], double *  mean_bins[], double *  rms_bins[], double *  min_bins[], double *  max_bins[], time_t *  bins_first_time[], double *  bins_first_value[], time_t *  bins_last_time[], double *  bins_last_value[], time_t  last_time[], double  last_value[], int  status[]  )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3373 of file history.cxx.

   {
      int status;
 
      MidasHistoryBinnedBuffer** buffer = new MidasHistoryBinnedBuffer*[num_var];
      MidasHistoryBufferInterface** xbuffer = new MidasHistoryBufferInterface*[num_var];
 
      for (int i=0; i<num_var; i++) {
         buffer[i] = new MidasHistoryBinnedBuffer(start_time, end_time, num_bins);
         xbuffer[i] = buffer[i];
 
         if (count_bins)
            buffer[i]->fCount = count_bins[i];
         if (mean_bins)
            buffer[i]->fMean = mean_bins[i];
         if (rms_bins)
            buffer[i]->fRms = rms_bins[i];
         if (min_bins)
            buffer[i]->fMin = min_bins[i];
         if (max_bins)
            buffer[i]->fMax = max_bins[i];
         if (bins_first_time)
            buffer[i]->fBinsFirstTime = bins_first_time[i];
         if (bins_first_value)
            buffer[i]->fBinsFirstValue = bins_first_value[i];
         if (bins_last_time)
            buffer[i]->fBinsLastTime = bins_last_time[i];
         if (bins_last_value)
            buffer[i]->fBinsLastValue = bins_last_value[i];
         if (last_time)
            buffer[i]->fLastTimePtr = &last_time[i];
         if (last_value)
            buffer[i]->fLastValuePtr = &last_value[i];
 
         buffer[i]->Start();
      }
 
      status = hs_read_buffer(start_time, end_time,
                              num_var, event_name, tag_name, var_index,
                              xbuffer,
                              read_status);
 
      for (int i=0; i<num_var; i++) {
         buffer[i]->Finish();
         if (num_entries)
            num_entries[i] = buffer[i]->fNumEntries;
         //if (0) {
         //   for (int j=0; j<num_bins; j++) {
         //      printf("var %d bin %d count %d, first %s last %s value first %f last %f\n", i, j, count_bins[i][j], TimeToString(bins_first_time[i][j]).c_str(), TimeToString(bins_last_time[i][j]).c_str(), bins_first_value[i][j], bins_last_value[i][j]);
         //   }
         //}
         delete buffer[i];
      }
 
      delete[] buffer;
      delete[] xbuffer;
 
      return status;
   }

Here is the call graph for this function:

hs_read_buffer()

int MidasHistory::hs_read_buffer ( time_t  start_time, time_t  end_time, int  num_var, const char *const  event_name[], const char *const  tag_name[], const int  var_index[], MidasHistoryBufferInterface *  buffer[], int  status[]  )

inlinevirtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3336 of file history.cxx.

   {
      for (int i=0; i<num_var; i++) {
         int event_id = 0;
 
         if (event_name[i]==NULL) {
            read_status[i] = HS_UNDEFINED_EVENT;
            continue;
         }
         
         int status = GetEventId(end_time, event_name[i], tag_name[i], &event_id);
         
         if (status != HS_SUCCESS) {
            read_status[i] = status;
            continue;
         }
         
         status = ::hs_read(event_id, (DWORD)start_time, (DWORD)end_time, 0,
                            tag_name[i], var_index[i],
                            NULL, NULL,
                            NULL, NULL,
                            NULL, NULL,
                            buffer[i]);
         
         if (fDebug) {
            printf("hs_read %d \'%s\' [%d] returned %d\n", event_id, tag_name[i], var_index[i], status);
         }
        
         read_status[i] = status;
      }
 
      return HS_SUCCESS;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

hs_search_file()

static INT hs_search_file ( DWORD *  ltime, INT  direction  )

static

Definition at line 353 of file history.cxx.

{
   time_t lt;
   int fh, fhd, fhi;
   std::string fn;
 
   ss_tzset(); // required by localtime_r()
 
   if (*ltime == 0)
      *ltime = ss_time();
 
   lt = (time_t) * ltime;
   do {
      /* try to open history file for date "lt" */
      hs_open_file(lt, "hst", O_RDONLY, &fn, &fh);
 
      /* if not found, look for next day */
      if (fh < 0)
         lt += direction * 3600 * 24;
 
      /* stop if more than a year before starting point or in the future */
   } while (fh < 0 && (INT) * ltime - (INT) lt < 3600 * 24 * 365 && lt <= (time_t) ss_time());
 
   if (fh < 0)
      return HS_FILE_ERROR;
 
   if (lt != (time_t) *ltime) {
      /* if switched to new day, set start_time to 0:00 */
      struct tm tms;
      localtime_r(&lt, &tms);
      tms.tm_hour = tms.tm_min = tms.tm_sec = 0;
      *ltime = (DWORD) ss_mktime(&tms);
   }
 
   /* check if index files are there */
   hs_open_file(*ltime, "idf", O_RDONLY, NULL, &fhd);
   hs_open_file(*ltime, "idx", O_RDONLY, NULL, &fhi);
 
   if (fh > 0)
      close(fh);
   if (fhd > 0)
      close(fhd);
   if (fhi > 0)
      close(fhi);
 
   /* generate them if not */
   if (fhd < 0 || fhi < 0)
      hs_gen_index(*ltime);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_set_debug()

int MidasHistory::hs_set_debug ( int  debug )

inlinevirtual

set debug level, returns previous debug level

Implements MidasHistoryInterface.

Definition at line 2266 of file history.cxx.

   {
      return debug;
   }

hs_set_path()

static INT hs_set_path ( const char *  path )

static

Sets the path for future history file accesses. Should be called before any other history function is called.

Parameters

path	Directory where history files reside

Returns

HS_SUCCESS

Definition at line 178 of file history.cxx.

{
   assert(path);
   assert(path[0] != 0);
   
   _hs_path_name = path;
 
   /* check for trailing directory seperator */
   if (_hs_path_name.back() != DIR_SEPARATOR)
      _hs_path_name += DIR_SEPARATOR_STR;
 
   return HS_SUCCESS;
}

Here is the caller graph for this function:

hs_to_double()

double hs_to_double	(	int	tid,
		const void *	ybuffer
	)

Definition at line 1420 of file history.cxx.

{
   int j = 0;
   /* convert data to float */
   switch (tid) {
   default:
      return 0;
   case TID_BYTE:
      return *(((BYTE *) ybuffer) + j);
   case TID_SBYTE:
      return *(((char *) ybuffer) + j);
   case TID_CHAR:
      return *(((char *) ybuffer) + j);
   case TID_WORD:
      return *(((WORD *) ybuffer) + j);
   case TID_SHORT:
      return *(((short *) ybuffer) + j);
   case TID_DWORD:
      return *(((DWORD *) ybuffer) + j);
   case TID_INT:
      return *(((INT *) ybuffer) + j);
   case TID_BOOL:
      return *(((BOOL *) ybuffer) + j);
   case TID_FLOAT:
      return *(((float *) ybuffer) + j);
   case TID_DOUBLE:
      return *(((double *) ybuffer) + j);
   }
   /* NOT REACHED */
}

Here is the caller graph for this function:

hs_write_event() [1/2]

int MidasHistory::hs_write_event ( const char *  event_name, time_t  timestamp, int  data_size, const char *  data  )

inlinevirtual

see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 2636 of file history.cxx.

   {
      int event_id = fEvidCache[event_name];
      //printf("write event [%s] evid %d\n", event_name, event_id);
      return ::hs_write_event(event_id, (void*)data, data_size);
   }

hs_write_event() [2/2]

static INT hs_write_event ( DWORD  event_id, const void *  data, DWORD  size  )

static

Definition at line 656 of file history.cxx.

{
   HIST_RECORD rec, drec;
   DEF_RECORD def_rec;
   INDEX_RECORD irec;
   int fh, fhi, fhd;
   DWORD last_pos_data, last_pos_index;
   std::string fn, fni, fnd;
   INT semaphore;
   int status;
   struct tm tmb, tmr;
   time_t ltime;
 
   /* request semaphore */
   cm_get_experiment_semaphore(NULL, NULL, &semaphore, NULL);
   status = ss_semaphore_wait_for(semaphore, 5 * 1000);
   if (status != SS_SUCCESS) {
      cm_msg(MERROR, "hs_write_event", "semaphore timeout");
      return SUCCESS;           /* someone else blocked the history system */
   }
 
   /* find index to history structure */
   int index = -1;
   for (unsigned i = 0; i < _history.size(); i++)
      if (_history[i]->event_id == event_id) {
         index = i;
         break;
      }
   if (index < 0) {
      ss_semaphore_release(semaphore);
      return HS_UNDEFINED_EVENT;
   }
 
   /* assemble record header */
   rec.record_type = RT_DATA;
   rec.event_id = _history[index]->event_id;
   rec.time = (DWORD) time(NULL);
   rec.def_offset = _history[index]->def_offset;
   rec.data_size = size;
 
   irec.event_id = _history[index]->event_id;
   irec.time = rec.time;
 
   /* check if new day */
   ltime = (time_t) rec.time;
   localtime_r(&ltime, &tmr); // somebody must call tzset() before this.
   ltime = (time_t) _history[index]->base_time;
   localtime_r(&ltime, &tmb); // somebody must call tzset() before this.
 
   if (tmr.tm_yday != tmb.tm_yday) {
      /* close current history file */
      close(_history[index]->hist_fh);
      close(_history[index]->def_fh);
      close(_history[index]->index_fh);
 
      /* open new history file */
      hs_open_file(rec.time, "hst", O_CREAT | O_RDWR, &fn, &fh);
      if (fh < 0) {
         ss_semaphore_release(semaphore);
         return HS_FILE_ERROR;
      }
 
      /* open new index file */
      hs_open_file(rec.time, "idx", O_CREAT | O_RDWR, &fni, &fhi);
      if (fhi < 0) {
         ss_semaphore_release(semaphore);
         return HS_FILE_ERROR;
      }
 
      /* open new definition index file */
      hs_open_file(rec.time, "idf", O_CREAT | O_RDWR, &fnd, &fhd);
      if (fhd < 0) {
         ss_semaphore_release(semaphore);
         return HS_FILE_ERROR;
      }
 
      xseek_end(fn, fh);
      xseek_end(fni, fhi);
      xseek_end(fnd, fhd);
 
      /* remember new file handles */
      _history[index]->hist_fn = fn;
      _history[index]->index_fn = fni;
      _history[index]->def_fn = fnd;
 
      _history[index]->hist_fh = fh;
      _history[index]->index_fh = fhi;
      _history[index]->def_fh = fhd;
 
      _history[index]->def_offset = xcurpos(fn, fh);
      rec.def_offset = _history[index]->def_offset;
 
      tmr.tm_hour = tmr.tm_min = tmr.tm_sec = 0;
      _history[index]->base_time = (DWORD) ss_mktime(&tmr);
 
      /* write definition from _history structure */
      drec.record_type = RT_DEF;
      drec.event_id = _history[index]->event_id;
      drec.time = rec.time;
      drec.data_size = _history[index]->n_tag * sizeof(TAG);
 
      xwrite(fn, fh, (char *) &drec, sizeof(drec));
      xwrite(fn, fh, _history[index]->event_name.c_str(), NAME_LENGTH);
      xwrite(fn, fh, (char *) _history[index]->tag, drec.data_size);
 
      /* write definition index record */
      def_rec.event_id = _history[index]->event_id;
      memcpy(def_rec.event_name, _history[index]->event_name.c_str(), sizeof(def_rec.event_name));
      def_rec.def_offset = _history[index]->def_offset;
      xwrite(fnd, fhd, (char *) &def_rec, sizeof(def_rec));
   }
 
   /* go to end of file */
   xseek_end(_history[index]->hist_fn, _history[index]->hist_fh);
   last_pos_data = irec.offset = xcurpos(_history[index]->hist_fn, _history[index]->hist_fh);
 
   /* write record header */
   xwrite(_history[index]->hist_fn, _history[index]->hist_fh, (char *) &rec, sizeof(rec));
 
   /* write data */
   if (!xwrite(_history[index]->hist_fn, _history[index]->hist_fh, (char *) data, size)) {
      /* disk maybe full? Do a roll-back! */
      xtruncate(_history[index]->hist_fn, _history[index]->hist_fh, last_pos_data);
      ss_semaphore_release(semaphore);
      return HS_FILE_ERROR;
   }
 
   /* write index record */
   xseek_end(_history[index]->index_fn, _history[index]->index_fh);
   last_pos_index = xcurpos(_history[index]->index_fn, _history[index]->index_fh);
   int size_of_irec = sizeof(irec);
   if (!xwrite(_history[index]->index_fn, _history[index]->index_fh, (char *) &irec, size_of_irec)) {
      /* disk maybe full? Do a roll-back! */
      xtruncate(_history[index]->hist_fn, _history[index]->hist_fh, last_pos_data);
      xtruncate(_history[index]->index_fn, _history[index]->index_fh, last_pos_index);
      ss_semaphore_release(semaphore);
      return HS_FILE_ERROR;
   }
 
   ss_semaphore_release(semaphore);
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MakeMidasHistory()

MidasHistoryInterface * MakeMidasHistory

(

)

Definition at line 3573 of file history.cxx.

{
#if 0
   // midas history is a singleton class
   static MidasHistory* gh = NULL;
   if (!gh)
      gh = new MidasHistory;
   return gh;
#endif
   return new MidasHistory();
}

Here is the caller graph for this function:

xcurpos()

static DWORD xcurpos ( const std::string &  fn, int  fh  )

static

Definition at line 133 of file history.cxx.

{
   off_t off = lseek(fh, 0, SEEK_CUR);
 
   if (off < 0) {
      cm_msg(MERROR, "xcurpos", "Error in lseek(0, SEEK_CUR) for file \"%s\", errno %d (%s)", fn.c_str(), errno, strerror(errno));
      return -1;
   }
 
   DWORD dw = off;
 
   if (dw != off) {
      cm_msg(MERROR, "xcurpos", "Error: lseek(0, SEEK_CUR) for file \"%s\" returned value %llu does not fir into a DWORD, maybe file is bigger than 2GiB or 4GiB", fn.c_str(), (unsigned long long)off);
      return -1;
   }
 
   return dw;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xread()

static int xread ( const std::string &  fn, int  fh, void *  buf, size_t  count, bool  eof_ok = false  )

static

Definition at line 73 of file history.cxx.

{
   ssize_t rd = read(fh, buf, count);
 
   if (rd < 0) {
      cm_msg(MERROR, "xread", "Error reading from file \"%s\" errno %d (%s)", fn.c_str(), errno, strerror(errno));
      return -1;
   }
 
   if (rd == 0) {
      if (eof_ok)
         return 0;
      cm_msg(MERROR, "xread", "Error: Unexpected end-of-file when reading file \"%s\"", fn.c_str());
      return -1;
   }
 
   if ((size_t)rd != count) {
      cm_msg(MERROR, "xread", "Error: Truncated read from file \"%s\", requested %d bytes, read %d bytes", fn.c_str(), (int)count, (int)rd);
      return -1;
   }
 
   return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xseek()

static bool xseek ( const std::string &  fn, int  fh, DWORD  pos  )

static

Definition at line 97 of file history.cxx.

{
   off_t off = lseek(fh, pos, SEEK_SET);
 
   if (off < 0) {
      cm_msg(MERROR, "xseek", "Error in lseek(%llu, SEEK_SET) for file \"%s\", errno %d (%s)", (unsigned long long)pos, fn.c_str(), errno, strerror(errno));
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xseek_cur()

static bool xseek_cur ( const std::string &  fn, int  fh, int  offset  )

static

Definition at line 121 of file history.cxx.

{
   off_t off = lseek(fh, offset, SEEK_CUR);
 
   if (off < 0) {
      cm_msg(MERROR, "xseek_cur", "Error in lseek(%d, SEEK_CUR) for file \"%s\", errno %d (%s)", offset, fn.c_str(), errno, strerror(errno));
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xseek_end()

static bool xseek_end ( const std::string &  fn, int  fh  )

static

Definition at line 109 of file history.cxx.

{
   off_t off = lseek(fh, 0, SEEK_END);
 
   if (off < 0) {
      cm_msg(MERROR, "xseek_end", "Error in lseek(SEEK_END) to end-of-file for file \"%s\", errno %d (%s)", fn.c_str(), errno, strerror(errno));
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xtruncate()

static bool xtruncate ( const std::string &  fn, int  fh, DWORD  pos  )

static

Definition at line 152 of file history.cxx.

{
   off_t off = lseek(fh, pos, SEEK_SET);
 
   if (off < 0) {
      cm_msg(MERROR, "xtruncate", "Error in lseek(%llu) for file \"%s\", errno %d (%s)", (unsigned long long)pos, fn.c_str(), errno, strerror(errno));
      return false;
   }
 
   int status = ftruncate(fh, pos);
 
   if (status != 0) {
      cm_msg(MERROR, "xtruncate", "Error setting file size of \"%s\" to %llu, errno %d (%s)", fn.c_str(), (unsigned long long)pos, errno, strerror(errno));
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xwrite()

static bool xwrite ( const std::string &  fn, int  fh, const void *  buf, size_t  count  )

static

dox

Definition at line 51 of file history.cxx.

{
   ssize_t wr = write(fh, buf, count);
 
   if (wr < 0) {
      cm_msg(MERROR, "xwrite", "Error writing %d bytes to file \"%s\" errno %d (%s)", (int)count, fn.c_str(), errno, strerror(errno));
      return false;
   }
 
   if ((size_t)wr != count) {
      cm_msg(MERROR, "xwrite", "Error writing %d bytes to file \"%s\", short write %d bytes", (int)count, fn.c_str(), (int)wr);
      return false;
   }
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_history

std::vector<HISTORY*> _history

static

dox

Definition at line 45 of file history.cxx.

_hs_path_name

std::string _hs_path_name

static

Definition at line 46 of file history.cxx.

fDB

HNDLE MidasHistory::fDB

Definition at line 2220 of file history.cxx.

fDebug

int MidasHistory::fDebug

Definition at line 2221 of file history.cxx.

fEventsCache

std::vector<std::string> MidasHistory::fEventsCache

Definition at line 2223 of file history.cxx.

fEvidCache

std::map<std::string, int > MidasHistory::fEvidCache

Definition at line 2225 of file history.cxx.

fTagsCache

std::map<std::string, std::vector<TAG> > MidasHistory::fTagsCache

Definition at line 2224 of file history.cxx.