Inheritance diagram for SchemaHistoryBase:

[legend]

Collaboration diagram for SchemaHistoryBase:

[legend]

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

Protected Attributes
int	fDebug

std::string	fConnectString

HsSchemaVector	fWriterCurrentSchema

std::vector< HsSchema * >	fEvents

HsSchemaVector	fSchema

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

char	type [NAME_LENGTH]
	history channel name

Detailed Description

Definition at line 3057 of file history_schema.cxx.

Constructor & Destructor Documentation

◆ SchemaHistoryBase()

SchemaHistoryBase::SchemaHistoryBase ( )

inline

Definition at line 3071 of file history_schema.cxx.

   {
      fDebug = 0;
   }

◆ ~SchemaHistoryBase()

virtual SchemaHistoryBase::~SchemaHistoryBase ( )

inlinevirtual

Definition at line 3076 of file history_schema.cxx.

   {
      for (unsigned i=0; i<fEvents.size(); i++)
         if (fEvents[i]) {
            delete fEvents[i];
            fEvents[i] = NULL;
         }
      fEvents.clear();
   }

Here is the call graph for this function:

Member Function Documentation

◆ hs_clear_cache()

int SchemaHistoryBase::hs_clear_cache ( )

virtual

clear internal cache, returns HS_SUCCESS

Implements MidasHistoryInterface.

Definition at line 3571 of file history_schema.cxx.

{
   if (fDebug)
      printf("SchemaHistoryBase::hs_clear_cache!\n");
 
   fWriterCurrentSchema.clear();
   fSchema.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 3395 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 (unsigned int i=0; i<fEvents.size(); i++)
      if (fEvents[i])
         if (event_name_cmp(fEvents[i]->fEventName, event_name)==0) {
            if (fDebug)
               printf("deleting exising event %s\n", event_name);
            fEvents[i]->close();
            delete fEvents[i];
            fEvents[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].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 (unsigned int i=0; i<fEvents.size(); i++)
      if (!fEvents[i]) {
         fEvents[i] = s;
         s = NULL;
         break;
      }
 
   // if no empty slots, add at the end
   if (s)
      fEvents.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 3550 of file history_schema.cxx.

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

Here is the call graph for this function:

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

{
   if (fDebug)
      printf("hs_get_events, time %s\n", TimeToString(t).c_str());
 
   int status = read_schema(&fSchema, NULL, t);
   if (status != HS_SUCCESS)
      return status;
 
   if (fDebug) {
      printf("hs_get_events: available schema:\n");
      fSchema.print(false);
   }
 
   assert(pevents);
 
   for (unsigned i=0; i<fSchema.size(); i++) {
      HsSchema* s = fSchema[i];
      if (t && s->fTimeTo && s->fTimeTo < t)
         continue;
      bool dupe = false;
      for (unsigned 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 %d events\n", (int)pevents->size());
      for (unsigned i=0; i<pevents->size(); i++) {
         printf("  %d: [%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 3683 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(&fSchema, event_name[i], 0);
      if (status != HS_SUCCESS)
         return status;
   }
 
   //fSchema.print(false);
 
   for (int i=0; i<num_var; i++) {
      for (unsigned ss=0; ss<fSchema.size(); ss++) {
         HsSchema* s = fSchema[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 3625 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(&fSchema, event_name, t);
   if (status != HS_SUCCESS)
      return status;
 
   bool found_event = false;
   for (unsigned i=0; i<fSchema.size(); i++) {
      HsSchema* s = fSchema[i];
      if (t && s->fTimeTo && s->fTimeTo < t)
         continue;
 
      if (event_name_cmp(s->fEventName, event_name) != 0)
         continue;
 
      found_event = true;
 
      for (unsigned 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 (unsigned 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 %d tags\n", event_name, (int)ptags->size());
      for (unsigned i=0; i<ptags->size(); i++) {
         printf("  tag[%d]: %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 3898 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 3947 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 3742 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(&fSchema, event_name[i], start_time);
      if (status != HS_SUCCESS)
         return status;
   }
 
#if 0
   if (fDebug)
      fSchema.print(false);
#endif
   
   for (int i=0; i<num_var; i++) {
      hs_status[i] = HS_UNDEFINED_VAR;
   }
 
   //for (unsigned ss=0; ss<fSchema.size(); ss++) {
   //   HsSchema* s = fSchema[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 (unsigned ss=0; ss<fSchema.size(); ss++) {
      if (fDebug) {
         //printf("Check schema %zu/%zu: prev from %s, this from %s to %s, compare %d %d %d\n", ss, fSchema.size(),
         //       TimeToString(fSchema[ss-1]->fTimeFrom).c_str(),
         //       TimeToString(fSchema[ss]->fTimeFrom).c_str(),
         //       TimeToString(fSchema[ss]->fTimeTo).c_str(),
         //       fSchema[ss-1]->fTimeFrom >= fSchema[ss]->fTimeTo,
         //       fSchema[ss-1]->fTimeFrom > fSchema[ss]->fTimeFrom,
         //       (fSchema[ss-1]->fTimeFrom >= fSchema[ss]->fTimeTo) && (fSchema[ss-1]->fTimeFrom > fSchema[ss]->fTimeFrom));
         printf("Schema %zu/%zu: from %s to %s, name %s\n", ss, fSchema.size(),
                TimeToString(fSchema[ss]->fTimeFrom).c_str(),
                TimeToString(fSchema[ss]->fTimeTo).c_str(),
                fSchema[ss]->fEventName.c_str());
      }
 
      if (ss > 0) {
         //if ((fSchema[ss-1]->fTimeFrom >= fSchema[ss]->fTimeTo) && (fSchema[ss-1]->fTimeFrom > fSchema[ss]->fTimeFrom)) {
         if ((fSchema[ss-1]->fTimeFrom >= fSchema[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 (unsigned ss=0; ss<fSchema.size(); ss++) {
      HsSchema* s = fSchema[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 %d matching schema:\n", (int)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);
   }
 
   for (int i=slist.size()-1; i>=0; 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;
         }
      }
   }
 
   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 3086 of file history_schema.cxx.

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

Here is the call graph for this function:

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

{
   if (fDebug)
      printf("hs_write_event: write event \'%s\', time %d, size %d\n", event_name, (int)timestamp, buffer_size);
 
   HsSchema *s = NULL;
 
   // find this event
   for (size_t i=0; i<fEvents.size(); i++)
      if (fEvents[i] && (event_name_cmp(fEvents[i]->fEventName, event_name)==0)) {
         s = fEvents[i];
         break;
      }
 
   // not found
   if (!s)
      return HS_UNDEFINED_EVENT;
 
   // deactivated because of error?
   if (s->fDisabled)
      return HS_FILE_ERROR;
 
   if (s->fNumBytes == 0) { // compute expected data size
      // NB: history data does not have any padding!
      for (unsigned 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 %d bytes, got %d 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 %d bytes, got %d 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:

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

◆ fDebug

int SchemaHistoryBase::fDebug

protected

Definition at line 3060 of file history_schema.cxx.

◆ fEvents

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

protected

Definition at line 3065 of file history_schema.cxx.

◆ fSchema

HsSchemaVector SchemaHistoryBase::fSchema

protected

Definition at line 3068 of file history_schema.cxx.

◆ fWriterCurrentSchema

HsSchemaVector SchemaHistoryBase::fWriterCurrentSchema

protected

Definition at line 3064 of file history_schema.cxx.

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

src/history_schema.cxx

Classes

Public Member Functions

Protected Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SchemaHistoryBase()

◆ ~SchemaHistoryBase()

Member Function Documentation

◆ hs_clear_cache()

◆ hs_connect()

◆ hs_define_event()

◆ hs_disconnect()

◆ hs_flush_buffers()

◆ hs_get_events()

◆ hs_get_last_written()

◆ hs_get_tags()

◆ hs_read()

◆ hs_read_binned()

◆ hs_read_buffer()

◆ hs_set_debug()

◆ hs_write_event()

◆ new_event()

◆ read_schema()

Member Data Documentation

◆ fConnectString

◆ fDebug

◆ fEvents

◆ fSchema

◆ fWriterCurrentSchema