336 lines
12 KiB
C++
336 lines
12 KiB
C++
//------------------------------------------------------------------------------
|
|
// Copyright (c) 1991,1992 Southeastern Universities Research Association,
|
|
// Continuous Electron Beam Accelerator Facility
|
|
//
|
|
// This software was developed under a United States Government license
|
|
// described in the NOTICE file included as part of this distribution.
|
|
//------------------------------------------------------------------------------
|
|
//
|
|
// description: rsvcDataEntry.h
|
|
// This file defines the classes necessary for storage of an individual
|
|
// tagged data item within a rsvcData class object.
|
|
//
|
|
// Author: Walt Akers & Jie Chen
|
|
//
|
|
//
|
|
//
|
|
//------------------------------------------------------------------------------
|
|
|
|
#ifndef _RSVC_DATA_ENTRY_H_
|
|
#define _RSVC_DATA_ENTRY_H_
|
|
|
|
#include <string.h>
|
|
#include <rsvcDataTypes.h>
|
|
|
|
// #############################################################################
|
|
// # rsvcDataEntryStorage:
|
|
// # This class contains the data elements and methods necessary to store data
|
|
// # associated with one tagged data item.
|
|
// #
|
|
// # Note: Because the rsvcData object must actively manipulate the data in
|
|
// # this structure - it has been made public to increase access speed
|
|
// # and to allow the subclassing of the rsvcData object.
|
|
// #############################################################################
|
|
class rsvcDataEntryStorage
|
|
{
|
|
public:
|
|
// *************************************************************
|
|
// * tag_:
|
|
// * This is char string value that is used to uniquely identify
|
|
// * a data element within a rsvcData object.
|
|
// *************************************************************
|
|
char tag_[RSVC_TAG_MAX_LEN];
|
|
|
|
// *************************************************************
|
|
// * dataType_:
|
|
// * This is the data type of the tagged data item that is to be
|
|
// * stored in this rsvcDataEntryStorage object.
|
|
// *************************************************************
|
|
rsvcDataTypes dataType_;
|
|
|
|
// *************************************************************
|
|
// * size_:
|
|
// * This variable is the allocated size of the buffer_ which is
|
|
// * used to store both the array data and its associated bounds
|
|
// * information.
|
|
// *************************************************************
|
|
size_t size_;
|
|
|
|
// *************************************************************
|
|
// * dim_:
|
|
// * This variable indicates the user specified number of
|
|
// * dimensions that the array represents.
|
|
// * either 0 or 1
|
|
// *************************************************************
|
|
size_t dim_;
|
|
|
|
// *************************************************************
|
|
// * elems_:
|
|
// * This variable contains the maximum number of elements that
|
|
// * the array may contain.
|
|
// *************************************************************
|
|
size_t elems_;
|
|
|
|
// *************************************************************
|
|
// * bytes_:
|
|
// * This variable contains the number of bytes per element.
|
|
// *************************************************************
|
|
size_t bytes_;
|
|
|
|
// *************************************************************
|
|
// * buffer_:
|
|
// * This is the buffer that is allocated to store data and
|
|
// * bounds information.
|
|
// *************************************************************
|
|
unsigned char * buffer_;
|
|
|
|
// *************************************************************
|
|
// * data_:
|
|
// * This is a union that is used to store scalar data and a
|
|
// * pointer to the array data this is stored within this object
|
|
// *************************************************************
|
|
union dataUnion {
|
|
BYTE cval;
|
|
short sval;
|
|
unsigned short usval;
|
|
long lval;
|
|
unsigned long ulval;
|
|
float fval;
|
|
double dval;
|
|
void * vptr;
|
|
BYTE * cptr;
|
|
short * sptr;
|
|
unsigned short * usptr;
|
|
long * lptr;
|
|
unsigned long * ulptr;
|
|
float * fptr;
|
|
double * dptr;
|
|
char * str;
|
|
char ** strarr;
|
|
rsvc_TS_STAMP ts;
|
|
rsvc_TS_STAMP * tsptr;
|
|
} data_;
|
|
|
|
// *************************************************************
|
|
// * rsvcDataEntryStorage:
|
|
// * Default constructor for the rsvcDataEntryStorage class. It sets
|
|
// * the buffer_ pointer to NULL to prevent deletion of non-
|
|
// * allocated memory, and then calls the clear method to
|
|
// * initialize all data variables.
|
|
// *************************************************************
|
|
rsvcDataEntryStorage ( void ) : buffer_(0) {
|
|
clear();
|
|
}
|
|
|
|
// *************************************************************
|
|
// * ~rsvcDataEntryStorage:
|
|
// * Default destructor for the rsvcDaaEntry class. It calls
|
|
// * the clear method to release and reinitialize all data
|
|
// * elements.
|
|
// *************************************************************
|
|
~rsvcDataEntryStorage ( void ) {
|
|
clear();
|
|
}
|
|
|
|
// *************************************************************
|
|
// * clear:
|
|
// * Releases and reinitializes all data variables.
|
|
// *************************************************************
|
|
void clear ( void ) {
|
|
deallocate();
|
|
tag_[0] = 0;
|
|
dataType_ = RSVC_INVALID;
|
|
}
|
|
|
|
// *************************************************************
|
|
// * allocate:
|
|
// * Allocates a block of memory sufficient to store a caller
|
|
// * specified number of bytes. If sufficient space has already
|
|
// * been allocated, then it will be used, otherwise, a new
|
|
// * block will be created to service the request.
|
|
// *************************************************************
|
|
void allocate ( size_t dimensions, size_t elems, size_t bytesPerElem )
|
|
{
|
|
size_t newBlockSize = (elems * bytesPerElem);
|
|
|
|
if(buffer_==NULL || newBlockSize>size_)
|
|
{
|
|
deallocate();
|
|
buffer_ = ::new unsigned char[newBlockSize];
|
|
size_ = newBlockSize;
|
|
}
|
|
dim_ = dimensions;
|
|
elems_ = elems;
|
|
bytes_ = bytesPerElem;
|
|
data_.vptr = &buffer_[0];
|
|
memset (buffer_, 0, newBlockSize);
|
|
}
|
|
|
|
// *************************************************************
|
|
// * deallocate:
|
|
// * Deallocates any memory previously allocated to the buffer
|
|
// * and reinitializes the size_, dim_, bytes_ and buffer_
|
|
// * variables. Any references to the previously allocated
|
|
// * block is cleared.
|
|
// *************************************************************
|
|
void deallocate ( void )
|
|
{
|
|
if(buffer_ != 0) {
|
|
delete []buffer_;
|
|
buffer_ = 0;
|
|
}
|
|
size_ = 0;
|
|
dim_ = 0;
|
|
elems_ = 0;
|
|
bytes_ = 0;
|
|
data_.dval = 0.00;
|
|
}
|
|
|
|
|
|
// *************************************************************
|
|
// * operator ==:
|
|
// * This operator allows you to directly and rapidly
|
|
// * compare two rsvcDataEntryStorage objects...
|
|
// *************************************************************
|
|
int operator == (rsvcDataEntryStorage & entry);
|
|
|
|
// *************************************************************
|
|
// * operator !=:
|
|
// * This operator allows the caller to directly and rapidly
|
|
// * comapre two rsvcDataEntryStorage objects.
|
|
// *************************************************************
|
|
int operator != (rsvcDataEntryStorage & entry) {
|
|
return !(operator == (entry));
|
|
}
|
|
|
|
};
|
|
|
|
|
|
// #############################################################################
|
|
// # rsvcDataEntry:
|
|
// # This class is used to define the node attributes necessary to support
|
|
// # linked lists of rsvcDataEntryStorage objects. It also provides an internal
|
|
// # freelist of rsvcDataEntry objects.
|
|
// #
|
|
// # Note: Because the rsvcData object must actively manipulate the data in
|
|
// # this structure - it has been made public to increase access speed
|
|
// # and to allow the subclassing of the rsvcData object.
|
|
// #############################################################################
|
|
class rsvcDataEntry : public rsvcDataEntryStorage
|
|
{
|
|
public:
|
|
// *************************************************************
|
|
// * freeList_:
|
|
// * This is a pointer to a list of currently allocated
|
|
// * rsvcDataEntrys that will be provided to the user
|
|
// * upon request. This technique should reduce the number of
|
|
// * mallocs called to allocated rsvcDataEntrys.
|
|
// *************************************************************
|
|
static rsvcDataEntry * freeList_;
|
|
|
|
// *************************************************************
|
|
// * ALLOCATION_COUNT:
|
|
// * This is the minimum number of rsvcDataEntrys that will
|
|
// * be allocated when the freeList_ becomes empty.
|
|
// *************************************************************
|
|
enum { ALLOCATION_COUNT = 16 };
|
|
|
|
// *************************************************************
|
|
// * next_ :
|
|
// * This is the pointer to the next element in the list of
|
|
// * rsvcDataEntry objects.
|
|
// *************************************************************
|
|
rsvcDataEntry * next_;
|
|
|
|
// *************************************************************
|
|
// * rsvcDataEntry:
|
|
// * Constructor for the class. It serves only to set the next_
|
|
// * pointer to NULL.
|
|
// *************************************************************
|
|
rsvcDataEntry ( void ) : next_(NULL), rsvcDataEntryStorage()
|
|
{
|
|
}
|
|
|
|
// *************************************************************
|
|
// * ~rsvcDataEntry:
|
|
// * Destructor for the class. It is a placeholder that
|
|
// * does nothing when called.
|
|
// *************************************************************
|
|
~rsvcDataEntry ( void ) { }
|
|
|
|
// *************************************************************
|
|
// * next:
|
|
// * Retrieves a pointer to the next_ rsvcDataEntry object.
|
|
// * Incorporation of this function into a list object is the
|
|
// * responsibility of the caller.
|
|
// *************************************************************
|
|
rsvcDataEntry * &next ( void )
|
|
{
|
|
return next_;
|
|
}
|
|
|
|
// *************************************************************
|
|
// * new:
|
|
// * Allocation function for the object. It will get the next
|
|
// * preallocated rsvcDataEntry object from the freeList_,
|
|
// * or, if none are available, refill the freeList_ and then
|
|
// * return a new rsvcDataEntry object.
|
|
// *************************************************************
|
|
void * operator new ( size_t size );
|
|
|
|
// *************************************************************
|
|
// * delete:
|
|
// * Rather than deallocating the rsvcDataEntry object, this
|
|
// * function returns it to the freeList_ where it may be
|
|
// * retrieved by a later call of new.
|
|
// *************************************************************
|
|
void operator delete ( void * ptr )
|
|
{
|
|
rsvcDataEntry * node = (rsvcDataEntry *)ptr;
|
|
if(node != NULL) {
|
|
node->next_ = freeList_;
|
|
freeList_ = node;
|
|
}
|
|
}
|
|
|
|
// *************************************************************
|
|
// * Copy operation
|
|
// * Copy an existing data entry to a new data entry
|
|
// * this may allow new data entry to be inserted into data object
|
|
// * quickly
|
|
// *************************************************************
|
|
rsvcDataEntry (const rsvcDataEntry& entry);
|
|
|
|
// *************************************************************
|
|
// * Assignment operation
|
|
// * Copy an existing data entry to a data entry
|
|
// *************************************************************
|
|
rsvcDataEntry& operator = (const rsvcDataEntry& entry);
|
|
|
|
// *************************************************************
|
|
// * operator ==:
|
|
// * This operator allows you to directly and rapidly
|
|
// * compare two rsvcDataEntry objects...
|
|
// *************************************************************
|
|
int operator == (rsvcDataEntry & entry)
|
|
{
|
|
rsvcDataEntryStorage *storage = &entry;
|
|
|
|
return rsvcDataEntryStorage::operator == (*storage);
|
|
}
|
|
|
|
// *************************************************************
|
|
// * operator !=:
|
|
// * This operator allows the caller to directly and rapidly
|
|
// * comapre two rsvcDataEntry objects.
|
|
// *************************************************************
|
|
int operator != (rsvcDataEntry & entry)
|
|
{
|
|
rsvcDataEntryStorage *storage = &entry;
|
|
return !(rsvcDataEntryStorage::operator == (*storage));
|
|
}
|
|
|
|
};
|
|
|
|
#endif /* __RSVC_DATA_ENTRY_H_ */
|