SchemaHistoryBase Class Reference

Inheritance diagram for SchemaHistoryBase:

Collaboration diagram for SchemaHistoryBase:

Classes
class	ReadBuffer

Public Member Functions
	SchemaHistoryBase ()
virtual	~SchemaHistoryBase ()
virtual int	hs_set_debug (int debug)
	set debug level, returns previous debug level
virtual int	hs_connect (const char *connect_string)=0
	returns HS_SUCCESS
virtual int	hs_disconnect ()=0
	disconnect from history, returns HS_SUCCESS
int	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	hs_write_event (const char *event_name, time_t timestamp, int buffer_size, const char *buffer)
	see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR
int	hs_flush_buffers ()
	flush buffered data to storage where it is visible to mhttpd
int	hs_clear_cache ()
	clear internal cache, returns HS_SUCCESS
int	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	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	hs_get_last_written (time_t timestamp, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], time_t last_written[])
int	hs_read_buffer (time_t start_time, time_t end_time, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], MidasHistoryBufferInterface *buffer[], int hs_status[])
	returns HS_SUCCESS
int	hs_read (time_t start_time, time_t end_time, time_t interval, int num_var, const char *const event_name[], const char *const var_name[], const int var_index[], int num_entries[], time_t *time_buffer[], double *data_buffer[], int st[])
	see hs_read(), returns HS_SUCCESS
int	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 var_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 st[])
	returns HS_SUCCESS
Public Member Functions inherited from MidasHistoryInterface
	MidasHistoryInterface ()
	history type: MIDAS, ODBC, SQLITE, etc
virtual	~MidasHistoryInterface ()

Protected Member Functions
virtual int	read_schema (HsSchemaVector *sv, const char *event_name, const time_t timestamp)=0
virtual HsSchema *	new_event (const char *event_name, time_t timestamp, int ntags, const TAG tags[])=0
virtual HsSchema *	maybe_reopen (const char *event_name, time_t timestamp, HsSchema *s)=0

Protected Attributes
int	fDebug = 0
std::string	fConnectString
HsSchemaVector	fWriterSchema
std::vector< HsSchema * >	fWriterEvents
HsSchemaVector	fReaderSchema

Additional Inherited Members
Public Attributes inherited from MidasHistoryInterface
char	name [NAME_LENGTH]
char	type [NAME_LENGTH]
	history channel name

Detailed Description

Definition at line 3150 of file history_schema.cxx.

Constructor & Destructor Documentation

SchemaHistoryBase()

SchemaHistoryBase::SchemaHistoryBase ( )

inline

Definition at line 3164 of file history_schema.cxx.

   {
      // empty
   }

~SchemaHistoryBase()

virtual SchemaHistoryBase::~SchemaHistoryBase ( )

inlinevirtual

Definition at line 3169 of file history_schema.cxx.

   {
      for (size_t i=0; i<fWriterEvents.size(); i++) {
         //printf("fWriterEvents[%zu] is %p\n", i, fWriterEvents[i]);
         if (fWriterEvents[i]) {
            delete fWriterEvents[i];
            fWriterEvents[i] = NULL;
         }
      }
      fWriterEvents.clear();
   }

Member Function Documentation

hs_clear_cache()

int SchemaHistoryBase::hs_clear_cache ( )

virtual

clear internal cache, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3683 of file history_schema.cxx.

{
   if (fDebug)
      printf("SchemaHistoryBase::hs_clear_cache!\n");
 
   fWriterSchema.clear();
   fReaderSchema.clear();
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_connect()

virtual int SchemaHistoryBase::hs_connect ( const char *  connect_string )

pure virtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Implemented in SqlHistoryBase, and FileHistory.

hs_define_event()

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

virtual

see hs_define_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 3493 of file history_schema.cxx.

{
   if (fDebug) {
      printf("hs_define_event: event name [%s] with %d tags\n", event_name, ntags);
      if (fDebug > 1)
         PrintTags(ntags, tags);
   }
 
   // delete all events with the same name
   for (size_t i=0; i<fWriterEvents.size(); i++)
      if (fWriterEvents[i])
         if (event_name_cmp(fWriterEvents[i]->fEventName, event_name)==0) {
            if (fDebug)
               printf("deleting exising event %s\n", event_name);
            fWriterEvents[i]->close();
            delete fWriterEvents[i];
            fWriterEvents[i] = NULL;
         }
 
   // check for wrong types etc
   for (int i=0; i<ntags; i++) {
      if (strlen(tags[i].name) < 1) {
         cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\' has empty name at index %d", event_name, i);
         return HS_FILE_ERROR;
      }
      if (tags[i].name[0] == ' ') {
         cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\' has name \'%s\' starting with a blank", event_name, tags[i].name);
         return HS_FILE_ERROR;
      }
      if (tags[i].type <= 0 || tags[i].type >= TID_LAST) {
         cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\' tag \'%s\' at index %d has invalid type %d",
                event_name, tags[i].name, i, tags[i].type);
         return HS_FILE_ERROR;
      }
      if (tags[i].type == TID_STRING) {
         cm_msg(MERROR, "hs_define_event",
                "Error: History event \'%s\' tag \'%s\' at index %d has forbidden type TID_STRING", event_name,
                tags[i].name, i);
         return HS_FILE_ERROR;
      }
      if (tags[i].n_data <= 0) {
         cm_msg(MERROR, "hs_define_event", "Error: History event \'%s\' tag \'%s\' at index %d has invalid n_data %d",
                event_name, tags[i].name, i, tags[i].n_data);
         return HS_FILE_ERROR;
      }
   }
 
   // check for duplicate names. Done by sorting, since this takes only O(N*log*N))
   std::vector<std::string> names;
   for (int i=0; i<ntags; i++) {
      std::string str(tags[i].name);
      std::transform(str.begin(), str.end(), str.begin(), ::toupper);
      names.push_back(str);
   }
   std::sort(names.begin(), names.end());
   for (int i=0; i<ntags-1; i++) {
      if (names[i] == names[i + 1]) {
         cm_msg(MERROR, "hs_define_event",
                "Error: History event \'%s\' has duplicate tag name \'%s\'", event_name,
                names[i].c_str());
         return HS_FILE_ERROR;
      }
   }
 
   HsSchema* s = new_event(event_name, timestamp, ntags, tags);
   if (!s)
      return HS_FILE_ERROR;
 
   s->fDisabled = false;
 
   s->remove_inactive_columns();
 
   // find empty slot in events list
   for (size_t i=0; i<fWriterEvents.size(); i++)
      if (!fWriterEvents[i]) {
         fWriterEvents[i] = s;
         s = NULL;
         break;
      }
 
   // if no empty slots, add at the end
   if (s)
      fWriterEvents.push_back(s);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_disconnect()

virtual int SchemaHistoryBase::hs_disconnect ( )

pure virtual

disconnect from history, returns HS_SUCCESS

Implements MidasHistoryInterface.

Implemented in SqlHistoryBase, and FileHistory.

hs_flush_buffers()

int SchemaHistoryBase::hs_flush_buffers ( )

virtual

flush buffered data to storage where it is visible to mhttpd

Implements MidasHistoryInterface.

Definition at line 3662 of file history_schema.cxx.

{
   int status = HS_SUCCESS;
 
   if (fDebug)
      printf("hs_flush_buffers!\n");
 
   for (size_t i=0; i<fWriterEvents.size(); i++)
      if (fWriterEvents[i]) {
         int xstatus = fWriterEvents[i]->flush_buffers();
         if (xstatus != HS_SUCCESS)
            status = xstatus;
      }
 
   return status;
}

Here is the caller graph for this function:

hs_get_events()

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

virtual

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 3694 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_get_events, time %s\n", TimeToString(t).c_str());
 
   int status = read_schema(&fReaderSchema, NULL, t);
   if (status != HS_SUCCESS)
      return status;
 
   if (fDebug) {
      printf("hs_get_events: available schema:\n");
      fReaderSchema.print(false);
   }
 
   assert(pevents);
 
   for (size_t i=0; i<fReaderSchema.size(); i++) {
      HsSchema* s = fReaderSchema[i];
      if (t && s->fTimeTo && s->fTimeTo < t)
         continue;
      bool dupe = false;
      for (size_t j=0; j<pevents->size(); j++)
         if (event_name_cmp((*pevents)[j], s->fEventName.c_str())==0) {
            dupe = true;
            break;
         }
 
      if (!dupe)
         pevents->push_back(s->fEventName);
   }
 
   std::sort(pevents->begin(), pevents->end());
 
   if (fDebug) {
      printf("hs_get_events: returning %zu events\n", pevents->size());
      for (size_t i=0; i<pevents->size(); i++) {
         printf("  %zu: [%s]\n", i, (*pevents)[i].c_str());
      }
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_get_last_written()

int SchemaHistoryBase::hs_get_last_written ( time_t  timestamp, int  num_var, const char *const  event_name[], const char *const  var_name[], const int  var_index[], time_t  last_written[]  )

virtual

Implements MidasHistoryInterface.

Definition at line 3795 of file history_schema.cxx.

{
   if (fDebug) {
      printf("hs_get_last_written: timestamp %s, num_var %d\n", TimeToString(timestamp).c_str(), num_var);
   }
 
   for (int j=0; j<num_var; j++) {
      last_written[j] = 0;
   }
 
   for (int i=0; i<num_var; i++) {
      int status = read_schema(&fReaderSchema, event_name[i], 0);
      if (status != HS_SUCCESS)
         return status;
   }
 
   //fReaderSchema.print(false);
 
   for (int i=0; i<num_var; i++) {
      for (size_t ss=0; ss<fReaderSchema.size(); ss++) {
         HsSchema* s = fReaderSchema[ss];
         // schema is too new
         if (s->fTimeFrom && s->fTimeFrom >= timestamp)
            continue;
         // this schema is newer than last_written and may contain newer data?
         if (s->fTimeFrom && s->fTimeFrom < last_written[i])
            continue;
         // schema for the variables we want?
         int sindex = s->match_event_var(event_name[i], var_name[i], var_index[i]);
         if (sindex < 0)
            continue;
 
         time_t lw = 0;
 
         int status = s->read_last_written(timestamp, fDebug, &lw);
 
         if (status == HS_SUCCESS && lw != 0) {
            for (int j=0; j<num_var; j++) {
               int sj = s->match_event_var(event_name[j], var_name[j], var_index[j]);
               if (sj < 0)
                  continue;
 
               if (lw > last_written[j])
                  last_written[j] = lw;
            }
         }
      }
   }
 
   if (fDebug) {
      printf("hs_get_last_written: timestamp time %s, num_var %d, result:\n", TimeToString(timestamp).c_str(), num_var);
      for (int i=0; i<num_var; i++) {
         printf("  event [%s] tag [%s] index [%d] last_written %s\n", event_name[i], var_name[i], var_index[i], TimeToString(last_written[i]).c_str());
      }
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_get_tags()

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

virtual

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 3737 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_get_tags: event [%s], time %s\n", event_name, TimeToString(t).c_str());
 
   assert(ptags);
 
   int status = read_schema(&fReaderSchema, event_name, t);
   if (status != HS_SUCCESS)
      return status;
 
   bool found_event = false;
   for (size_t i=0; i<fReaderSchema.size(); i++) {
      HsSchema* s = fReaderSchema[i];
      if (t && s->fTimeTo && s->fTimeTo < t)
         continue;
 
      if (event_name_cmp(s->fEventName, event_name) != 0)
         continue;
 
      found_event = true;
 
      for (size_t i=0; i<s->fVariables.size(); i++) {
         const char* tagname = s->fVariables[i].name.c_str();
         //printf("event_name [%s], table_name [%s], column name [%s], tag name [%s]\n", event_name, tn.c_str(), cn.c_str(), tagname);
 
         bool dupe = false;
 
         for (size_t k=0; k<ptags->size(); k++)
            if (strcasecmp((*ptags)[k].name, tagname) == 0) {
               dupe = true;
               break;
            }
 
         if (!dupe) {
            TAG t;
            mstrlcpy(t.name, tagname, sizeof(t.name));
            t.type = s->fVariables[i].type;
            t.n_data = s->fVariables[i].n_data;
 
            ptags->push_back(t);
         }
      }
   }
 
   if (!found_event)
      return HS_UNDEFINED_EVENT;
 
   if (fDebug) {
      printf("hs_get_tags: event [%s], returning %zu tags\n", event_name, ptags->size());
      for (size_t i=0; i<ptags->size(); i++) {
         printf("  tag[%zu]: %s[%d] type %d\n", i, (*ptags)[i].name, (*ptags)[i].n_data, (*ptags)[i].type);
      }
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

hs_read()

int SchemaHistoryBase::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[]  )

virtual

see hs_read(), returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 4015 of file history_schema.cxx.

{
   int status;
 
   ReadBuffer** buffer = new ReadBuffer*[num_var];
   MidasHistoryBufferInterface** bi = new MidasHistoryBufferInterface*[num_var];
 
   for (int i=0; i<num_var; i++) {
      buffer[i] = new ReadBuffer(start_time, end_time, interval);
      bi[i] = buffer[i];
 
      // make sure outputs are initialized to something sane
      if (num_entries)
         num_entries[i] = 0;
      if (time_buffer)
         time_buffer[i] = NULL;
      if (data_buffer)
         data_buffer[i] = NULL;
      if (st)
         st[i] = 0;
 
      if (num_entries)
         buffer[i]->fNumEntries = &num_entries[i];
      if (time_buffer)
         buffer[i]->fTimeBuffer = &time_buffer[i];
      if (data_buffer)
         buffer[i]->fDataBuffer = &data_buffer[i];
   }
 
   status = hs_read_buffer(start_time, end_time,
                           num_var, event_name, var_name, var_index,
                           bi, st);
 
   for (int i=0; i<num_var; i++) {
      buffer[i]->Finish();
      delete buffer[i];
   }
 
   delete[] buffer;
   delete[] bi;
 
   return status;
}

Here is the call graph for this function:

hs_read_binned()

int SchemaHistoryBase::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[]  )

virtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 4064 of file history_schema.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, var_name, var_index,
                           xbuffer,
                           st);
 
   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 SchemaHistoryBase::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[]  )

virtual

returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3854 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_read_buffer: %d variables, start time %s, end time %s\n", num_var, TimeToString(start_time).c_str(), TimeToString(end_time).c_str());
 
   for (int i=0; i<num_var; i++) {
      int status = read_schema(&fReaderSchema, event_name[i], start_time);
      if (status != HS_SUCCESS)
         return status;
   }
 
#if 0
   if (fDebug)
      fReaderSchema.print(false);
#endif
   
   for (int i=0; i<num_var; i++) {
      hs_status[i] = HS_UNDEFINED_VAR;
   }
 
   //for (size_t ss=0; ss<fReaderSchema.size(); ss++) {
   //   HsSchema* s = fReaderSchema[ss];
   //   HsFileSchema* fs = dynamic_cast<HsFileSchema*>(s);
   //   assert(fs != NULL);
   //   printf("schema %d from %s to %s, filename %s\n", ss, TimeToString(fs->fTimeFrom).c_str(),  TimeToString(fs->fTimeTo).c_str(), fs->fFileName.c_str());
   //}
 
   // check that schema are sorted by time
 
#if 0
   // check that schema list is sorted by time, descending fTimeFrom, newest schema first
   for (size_t ss=0; ss<fReaderSchema.size(); ss++) {
      if (fDebug) {
         //printf("Check schema %zu/%zu: prev from %s, this from %s to %s, compare %d %d %d\n", ss, fReaderSchema.size(),
         //       TimeToString(fReaderSchema[ss-1]->fTimeFrom).c_str(),
         //       TimeToString(fReaderSchema[ss]->fTimeFrom).c_str(),
         //       TimeToString(fReaderSchema[ss]->fTimeTo).c_str(),
         //       fReaderSchema[ss-1]->fTimeFrom >= fReaderSchema[ss]->fTimeTo,
         //       fReaderSchema[ss-1]->fTimeFrom > fReaderSchema[ss]->fTimeFrom,
         //       (fReaderSchema[ss-1]->fTimeFrom >= fReaderSchema[ss]->fTimeTo) && (fReaderSchema[ss-1]->fTimeFrom > fReaderSchema[ss]->fTimeFrom));
         printf("Schema %zu/%zu: from %s to %s, name %s\n", ss, fReaderSchema.size(),
                TimeToString(fReaderSchema[ss]->fTimeFrom).c_str(),
                TimeToString(fReaderSchema[ss]->fTimeTo).c_str(),
                fReaderSchema[ss]->fEventName.c_str());
      }
 
      if (ss > 0) {
         //if ((fReaderSchema[ss-1]->fTimeFrom >= fReaderSchema[ss]->fTimeTo) && (fReaderSchema[ss-1]->fTimeFrom > fReaderSchema[ss]->fTimeFrom)) {
         if ((fReaderSchema[ss-1]->fTimeFrom >= fReaderSchema[ss]->fTimeFrom)) {
            // good
         } else {
            cm_msg(MERROR, "SchemaHistoryBase::hs_read_buffer", "History internal error, schema is not ordered by time. Please report this error to the midas forum.");
            return HS_FILE_ERROR;
         }
      }
   }
#endif
 
   std::vector<HsSchema*> slist;
   std::vector<std::vector<int>> smap;
 
   for (size_t ss=0; ss<fReaderSchema.size(); ss++) {
      HsSchema* s = fReaderSchema[ss];
      // schema is too new?
      if (s->fTimeFrom && s->fTimeFrom > end_time)
         continue;
      // schema is too old
      if (s->fTimeTo && s->fTimeTo < start_time)
         continue;
 
      std::vector<int> sm;
 
      for (int i=0; i<num_var; i++) {
         // schema for the variables we want?
         int sindex = s->match_event_var(event_name[i], var_name[i], var_index[i]);
         if (sindex < 0)
            continue;
 
         if (sm.empty()) {
            for (int i=0; i<num_var; i++) {
               sm.push_back(-1);
            }
         }
 
         sm[i] = sindex;
      }
 
      if (!sm.empty()) {
         slist.push_back(s);
         smap.push_back(sm);
      }
   }
 
   if (0||fDebug) {
      printf("Found %zu matching schema:\n", slist.size());
 
      for (size_t i=0; i<slist.size(); i++) {
         HsSchema* s = slist[i];
         s->print();
         for (int k=0; k<num_var; k++)
            printf("  tag %s[%d] sindex %d\n", var_name[k], var_index[k], smap[i][k]);
      }
   }
 
   //for (size_t ss=0; ss<slist.size(); ss++) {
   //   HsSchema* s = slist[ss];
   //   HsFileSchema* fs = dynamic_cast<HsFileSchema*>(s);
   //   assert(fs != NULL);
   //   printf("schema %zu from %s to %s, filename %s", ss, TimeToString(fs->fTimeFrom).c_str(),  TimeToString(fs->fTimeTo).c_str(), fs->fFileName.c_str());
   //   printf(" smap ");
   //   for (int k=0; k<num_var; k++)
   //      printf(" %2d", smap[ss][k]);
   //   printf("\n");
   //}
 
   for (size_t ss=1; ss<slist.size(); ss++) {
      if (fDebug) {
         printf("Check schema %zu/%zu: prev from %s, this from %s to %s, compare %d\n", ss, slist.size(),
                TimeToString(slist[ss-1]->fTimeFrom).c_str(),
                TimeToString(slist[ss]->fTimeFrom).c_str(),
                TimeToString(slist[ss]->fTimeTo).c_str(),
                slist[ss-1]->fTimeFrom >= slist[ss]->fTimeFrom);
      }
      if (slist[ss-1]->fTimeFrom >= slist[ss]->fTimeFrom) {
         // good
      } else {
         cm_msg(MERROR, "SchemaHistoryBase::hs_read_buffer", "History internal error, selected schema is not ordered by time. Please report this error to the midas forum.");
         return HS_FILE_ERROR;
      }
   }
 
   std::vector<time_t> last_time;
 
   for (int i=0; i<num_var; i++) {
      last_time.push_back(start_time);
   }
 
   if (slist.size() > 0) {
      for (size_t i=slist.size()-1; ; i--) {
         HsSchema* s = slist[i];
 
         int status = s->read_data(start_time, end_time, num_var, smap[i], var_index, fDebug, last_time, buffer);
 
         if (status == HS_SUCCESS) {
            for (int j=0; j<num_var; j++) {
               if (smap[i][j] >= 0)
                  hs_status[j] = HS_SUCCESS;
            }
         }
 
         if (i==0)
            break;
      }
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hs_set_debug()

virtual int SchemaHistoryBase::hs_set_debug ( int  debug )

inlinevirtual

set debug level, returns previous debug level

Implements MidasHistoryInterface.

Reimplemented in SqlHistoryBase.

Definition at line 3181 of file history_schema.cxx.

   {
      int old = fDebug;
      fDebug = debug;
      return old;
   }

Here is the caller graph for this function:

hs_write_event()

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

virtual

see hs_write_event(), returns HS_SUCCESS or HS_FILE_ERROR

Implements MidasHistoryInterface.

Definition at line 3580 of file history_schema.cxx.

{
   if (fDebug)
      printf("hs_write_event: write event \'%s\', time %d, size %d\n", event_name, (int)timestamp, xbuffer_size);
 
   assert(xbuffer_size > 0);
 
   size_t buffer_size = xbuffer_size;
 
   HsSchema *s = NULL;
 
   // find this event
   for (size_t i=0; i<fWriterEvents.size(); i++)
      if (fWriterEvents[i] && (event_name_cmp(fWriterEvents[i]->fEventName, event_name)==0)) {
         s = fWriterEvents[i];
         break;
      }
 
   // not found
   if (!s)
      return HS_UNDEFINED_EVENT;
 
   // deactivated because of error?
   if (s->fDisabled) {
      //printf("HERE!\n");
      return HS_FILE_ERROR;
   }
 
   s = maybe_reopen(event_name, timestamp, s);
 
   assert(s != NULL);
 
   if (s->fNumBytes == 0) { // compute expected data size
      // NB: history data does not have any padding!
      for (size_t i=0; i<s->fVariables.size(); i++) {
         s->fNumBytes += s->fVariables[i].n_bytes;
      }
   }
 
   int status;
 
   if (buffer_size > s->fNumBytes) { // too many bytes!
      if (s->fCountWriteOversize == 0) {
         // only report first occurence
         // count of all occurences is reported by HsSchema destructor
         cm_msg(MERROR, "hs_write_event", "Event \'%s\' data size mismatch: expected %zu bytes, got %zu bytes", s->fEventName.c_str(), s->fNumBytes, buffer_size);
      }
      s->fCountWriteOversize++;
      if (buffer_size > s->fWriteMaxSize)
         s->fWriteMaxSize = buffer_size;
      status = s->write_event(timestamp, buffer, s->fNumBytes);
   } else if (buffer_size < s->fNumBytes) { // too few bytes
      if (s->fCountWriteUndersize == 0) {
         // only report first occurence
         // count of all occurences is reported by HsSchema destructor
         cm_msg(MERROR, "hs_write_event", "Event \'%s\' data size mismatch: expected %zu bytes, got %zu bytes", s->fEventName.c_str(), s->fNumBytes, buffer_size);
      }
      s->fCountWriteUndersize++;
      if (s->fWriteMinSize == 0)
         s->fWriteMinSize = buffer_size;
      else if (buffer_size < s->fWriteMinSize)
         s->fWriteMinSize = buffer_size;
      char* tmp = (char*)malloc(s->fNumBytes);
      memcpy(tmp, buffer, buffer_size);
      memset(tmp + buffer_size, 0, s->fNumBytes - buffer_size);
      status = s->write_event(timestamp, tmp, s->fNumBytes);
      free(tmp);
   } else {
      assert(buffer_size == s->fNumBytes); // obviously
      status = s->write_event(timestamp, buffer, buffer_size);
   }
 
   // if could not write event, deactivate it
   if (status != HS_SUCCESS) {
      s->fDisabled = true;
      cm_msg(MERROR, "hs_write_event", "Event \'%s\' disabled after write error %d", event_name, status);
      return HS_FILE_ERROR;
   }
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

maybe_reopen()

virtual HsSchema * SchemaHistoryBase::maybe_reopen ( const char *  event_name, time_t  timestamp, HsSchema *  s  )

protectedpure virtual

Implemented in SqlHistoryBase, and FileHistory.

Here is the caller graph for this function:

new_event()

virtual HsSchema * SchemaHistoryBase::new_event ( const char *  event_name, time_t  timestamp, int  ntags, const TAG  tags[]  )

protectedpure virtual

Implemented in SqlHistoryBase, and FileHistory.

Here is the caller graph for this function:

read_schema()

virtual int SchemaHistoryBase::read_schema ( HsSchemaVector *  sv, const char *  event_name, const time_t  timestamp  )

protectedpure virtual

Implemented in SqlHistoryBase, and FileHistory.

Here is the caller graph for this function:

Member Data Documentation

fConnectString

std::string SchemaHistoryBase::fConnectString

protected

Definition at line 3154 of file history_schema.cxx.

fDebug

int SchemaHistoryBase::fDebug = 0

protected

Definition at line 3153 of file history_schema.cxx.

fReaderSchema

HsSchemaVector SchemaHistoryBase::fReaderSchema

protected

Definition at line 3161 of file history_schema.cxx.

fWriterEvents

std::vector<HsSchema*> SchemaHistoryBase::fWriterEvents

protected

Definition at line 3158 of file history_schema.cxx.

fWriterSchema

HsSchemaVector SchemaHistoryBase::fWriterSchema

protected

Definition at line 3157 of file history_schema.cxx.

---

The documentation for this class was generated from the following file:

• src/history_schema.cxx