diff --git a/documentation/pvDataCpp.html b/documentation/pvDataCpp.html
new file mode 100644
index 0000000..d35f143
--- /dev/null
+++ b/documentation/pvDataCpp.html
@@ -0,0 +1,3358 @@
+
+
+
+
+
+ EPICS pvDataCPP
+
+
+
+EPICS pvDataCPP
+Overview
+2010.12.02
+
+TODO
+
+ - rename epicsException to exception
+ - Implement pvMisc: BitSetUtil MessageQueue, MultiChoice,Status, and
+ Queue
+ - Implement property
+
+CONTENTS
+
+
+Introduction
+
+
+This product is available via the open source
+license described at the end of this document.
+
+PVData is one of a set of related projects. It describes and implements
+the data that the other projects support. Thus it is not useful by itself but
+understanding pvData is required in order to understand the other projects.
+The reader should also become familar with projects pvAccess and javaIOC,
+which are located via the same sourceforge site as this project. Project
+PVAccess provides network support for transporting pvData. Project javaIOC
+provides a memory resident "smart" database of pvData data.
+
+This document describes the C++ implementation of pvData, which was first
+implemented in Java. A C++ implementation of pvAccess is being developed in
+parallel with pvDataCPP. In the future a C++ implementation of javaIOC will
+be developed and the name javaIOV will become pvIOC.
+
+pvData (Process Variable Data) defines and implements an efficent way to
+store, access, and transmit memory resident structured data.
+
+ - definition
+ - The header files pvIntrospect.h and pvData.h provide the C++
+ description of pvData.
+ - implementation
+ - Ditrectory factory provides a complete C++ definition for pvData. It
+ also proivides abstract and base classes that allow specialized
+ implementations of the data classes.
+ - efficient
+ - Small memory footprint, low cpu overhead, and concise code base.
+ - data storage
+ - pvData defines separate introspection and data interfaces. The
+ introspection interfaces provide access to immutable objects, which
+ allows introspection instances to be freely shared. The introspection
+ interface for a process variable can be accessed without requiring
+ access to the data.
+ - data access
+ - Client code can access pvData via the introspection and data
+ interfaces. For "well known" data, e.g. timeStamp, specialized
+ interfaces can be provided without requiring any changes to the core
+ software.
+ - data transfer
+ - The separation of introspection and data interfaces allows for
+ efficient network data transfer. At connection time introspection
+ information can be passed from server to client. Each side can create a
+ data instance. The data is transferred between these instances. The
+ data in the network buffers does not have to be self describing since
+ each side has the introspection information.
+ - memory resident
+ - pvData only defines memory resident data.
+ - structured data
+ - pvData has four types: scalar, scalar array, structure, and structure
+ array. A scalar can be one of the following: boolean, byte, short, int,
+ long, float, double, string. A scalar array is a one dimensional array
+ with the element type being a scalar. A structure is an ordered set of
+ fields where each field has a name and type. A structure array is a one
+ dimensional array of structures where each element has the same
+ introspection interface. Since a field can have type structure complex
+ structures are supported. No other types are needed since structures
+ can be defined that simulate types.
+
+
+The javaIOC implements a Process Variable (PV) Database, which is a memory
+resident database holding pvData, has the following features:
+
+ - A database has records.
+ - Each record has a unique record name.
+ - A record has a top level PVStructure, which is a structured set of data
+ as defined by this project.
+ - A PVStructure has an array of PVFields.
+ - A PVField contains data of one of the following types:
+
+ - scalar : boolean, byte, short, int, long, float, double, string,
+ structure
+ - array: a 1-dim array with the elementType being any scalar
+ type.
+ - structure: a subStructure with each field being any of the
+ supported types.
+
+
+
+
+pvData was initially created to support the javaIOC and was part of the
+javaIOC project. It is now a separate project that is used by the javaIOC. In
+addition to the javaIOC, pvData is intended for use by 1) channel access
+clients, 2) Interface between client and network, 3) Interface between
+network and channel access server, 4) Interface between server and IOC
+database. Since it is an interface to data, it could also be used by other
+systems, e.g. TANGO, TINE, etc. A high level Physics application can hold
+data as pvData. By starting a channel access server, the data can made
+available to network clients.
+
+pvData contains everything required to support Channel Access and Channel
+Access clients and servers.
+
+This project has many concepts that are similar to EPICS (Experimental
+Physics and Industrial Control System). This C++ implementation uses the
+EPICS build system and also EPICS libCom. The directory structure for this
+project is a standard EPICS application. The following source directories
+appear under pvDataApp:
+
+ - misc
+ - Support for pvData. This support is described in a major section
+ below.
+ - pv
+ - The C++ introspection and data descriptions for pvData.
+ - factory
+ - The C++ definitions for pvData.
+ - property
+ - Support code for "standard" pvData structures, e.g. timeStamp and
+ alarm.
+
+
+
+Namespace, Typedefs, and Memory Management
+
+
+Namespace
+
+All include and definition files in project pvDataCPP appear in namespace:
+
+namespace epics { namespace pvData {
+ // ...
+}}
+
+typedefs
+
+Directory misc has an include file pvTypes.h:
+typedef signed char int8;
+typedef short int16;
+typedef int int32;
+typedef long long int64;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+
+typedef std::string String;
+typedef std::string * StringBuilder;
+typedef String* StringArray;
+
+The integer typedefs provide the definitions for various sizes of integer
+values. The relationship between these definitions and the ScalarType
+description is:
+
+ - pvBoolean
+ - bool
+ - pvByte
+ - int8
+ - pvShort
+ - int16
+ - pvInt
+ - int32
+ - pvLong
+ - int64
+ - pvString
+ - String
+
+
+It is hoped that all modern C++ compilers will properly handle the integer
+typedefs but if not than there is a good chance that it can be supported by
+changes to pvInterspect.h.
+
+std::string is used to implement pvString. This works because std::string
+implement COW (Copy On Write) semantics. Thus once created a String can be
+treated like an immutable object, which is what pvData require.
+
+The remaining definitions are:
+
+ - StringBuilder
+ - This acts like the java StringBuilder when is is passed as an
+ argument to a function.
+ - StringArray
+ - This is an array with each element being a String.
+
+
+File pvInterspect.h, which is described in the next section has the
+typedefs:
+typedef Field const * FieldConstPtr;
+typedef FieldConstPtr * FieldConstPtrArray;
+typedef Scalar const * ScalarConstPtr;
+typedef ScalarArray const * ScalarArrayConstPtr;
+typedef Structure const * StructureConstPtr;
+typedef StructureArray const * StructureArrayConstPtr;
+
+These are definitions for introspection objects. All introspecton objects
+are immutable and always accessed via pointers.
+
+File pvData.h, which is also described in the next section has the
+typedefs:
+typedef std::map<String,PVScalar * > PVScalarMap;
+typedef PVScalarMap::const_iterator PVScalarMapIter;
+typedef PVStructure * PVStructurePtr;
+typedef PVStructurePtr* PVStructurePtrArray;
+typedef PVField* PVFieldPtr;
+typedef PVFieldPtr * PVFieldPtrArray;
+typedef bool * BooleanArray;
+typedef int8 * ByteArray;
+typedef int16 * ShortArray;
+typedef int32 * IntArray;
+typedef int64 * LongArray;
+typedef float * FloatArray;
+typedef double * DoubleArray;
+typedef String * StringArray;
+
+where
+
+ - PVScalarMap and PVScalarMapIter
+ - A map and iterator that maps field names to PVScalars.
+ - PVStructurePtr
+ - A pointer to a PVStructure.
+ - PVStructurePtrArray
+ - A pointer to PVStructurePtr[], e. g. an array of pointers to a
+ PVStructure.
+ - PVFieldPtr
+ - A pointer to a PVField
+ - PVFieldPtrArray
+ - A pointer to a PVFieldPtr[], e. g. an array of pointers to a
+ PVField.
+ - BooleanArray, ByteArray, ...,
+ StringArray
+ - An array of the specified type NOT a pointer to the type.
+
+
+Memory Managemment
+
+NoDefaultMethods
+
+Any class that does not allow the compiler to generate default methods can
+privately extend the following class which is defined in file
+noDefaultMethods.h:
+class NoDefaultMethods {
+protected:
+ // allow by derived objects
+ NoDefaultMethods(){};
+ ~NoDefaultMethods(){}
+private:
+ // do not implment
+ NoDefaultMethods(const NoDefaultMethods&);
+ NoDefaultMethods & operator=(const NoDefaultMethods &);
+};
+
+PVData introspection objects
+
+Introspection objects are meant to be shared. The constructors and
+destructors are all private so that an introspection object can only be
+created via a call to one of the FieldCreate methods described below. The
+introspection implementation, together with AbstractPVField keeps reference
+counts and automatically deletes objects when the reference count goes to 0.
+Code that uses introspection objects always accesses introspection objects
+via pointers never via references or direct access to the object. When a
+PVData data object is destroyed then pointers to the introspection objects
+associated with the data object are no longer valid.
+
+PVData data objects
+
+All PVData data objects must publically extend AbstractPVField, which does
+not allow default methods but does have a virtual destructor. It is expected
+that each data object is "owned" by some entity. For example a pvIOC (not
+implemented) database will own all records and thus all PVData data objects
+in the database. It is the ONLY entity that will create and destroy the data
+objects. All other code only receives pointers to the data objects. Before a
+record is deleted any code that is connected to a record is notified before
+the record is deleted. After deletion all pointers to data in the record are
+invalid. Similarly pvAccess creates and destroys PVData objects and notifies
+clients before destroying PVData data objects.
+
+Other code in this project
+
+If a class is pure data, e. g. TimeStamp, then it acts list like a
+primitive object.
+
+Other clases privately extend NoDefaultClasses and are not normally meant
+to be extended. Thus they can only be created via "new" and must be destroyed
+via "delete". These classes normally implement the static method:
+ static ConstructDestructCallback *getConstructDestructCallback();
+
+This provides access to how many objects have been constructed and
+destructed. This can be used to monitor memory usage.
+
+
+
+
+Miscellanous Classes
+
+
+Overview
+
+This package provides utility code:
+
+ - bitSet.h
+ - An implementation of BitSet that can be serialized.
+ - byteBuffer.h
+ - Used to serialize objects.
+ - event.h
+ - Signal and wait for an event.
+ - exception.h
+ - Exception with stack trace.
+ - executor.h
+ - Provides a thread for executing commands.
+ - linkedList.h
+ - A double linked list facility that requires the user to allocate a
+ node. It is more efficient that std::list and does not require the
+ implementation to allocate storage for the nodes.
+ - lock.h
+ - Support for locking and unlocking.
+ - messageQueue.h
+ - Support for queuing messages to give to requesters.
+ - noDefaultMethods.h
+ - When privately extended prevents compiler from implementing default
+ methods.
+ - pvType.h
+ - Provides architecture independent definitions for integers and
+ String.
+ - requester.h
+ - Allows messages to be sent to a requester.
+ - serialize.h
+ - Support for serializing objects.
+ - showConstructDestruct.h
+ - Provides support monitoring memory usage for objects of a class.
+ - status.h
+ - A way to pass status information to a client.
+ - thread.h
+ - Provides thread support.
+ - timeFunction.h
+ - Time how long a function call requires.
+ - timer.h
+ - An implementation of Timer that does not require an object to be
+ created for each timer request.
+ - timeStamp.h
+ - Usefull methods for a timeStamp.
+ - queue.h
+ - A queue implementation that allows the latest queue element to
+ continue to be used when no free element is available.
+
+
+BitSet
+
+This is adapted from the java.util.BitSet. bitSet.h is:
+class BitSet /*: public Serializable*/ {
+public:
+ BitSet();
+ BitSet(uint32 nbits);
+ virtual ~BitSet();
+ void flip(uint32 bitIndex);
+ void set(uint32 bitIndex);
+ void clear(uint32 bitIndex);
+ void set(uint32 bitIndex, bool value);
+ bool get(uint32 bitIndex) const;
+ void clear();
+ int32 nextSetBit(uint32 fromIndex) const;
+ int32 nextClearBit(uint32 fromIndex) const;
+ bool isEmpty() const;
+ uint32 cardinality() const;
+ BitSet& operator&=(const BitSet& set);
+ BitSet& operator|=(const BitSet& set);
+ BitSet& operator^=(const BitSet& set);
+ BitSet& operator-=(const BitSet& set);
+ BitSet& operator=(const BitSet &set);
+ void or_and(const BitSet& set1, const BitSet& set2);
+ bool operator==(const BitSet &set) const;
+ bool operator!=(const BitSet &set) const;
+ void toString(StringBuilder buffer);
+ void toString(StringBuilder buffer, int indentLevel) const;
+private:
+};
+
+where
+
+ - BitSet()
+ - Creates a bitSet of initial size 64 bits. All bits initially
+ false.
+ - BitSet(uint32 nbits)
+ - Creates a bitSet with the initial of the specified number of bits.
+ All bits initially false.
+ - ~BitSet()
+ - Destructor.
+ - flip(uint32 bitIndex)
+ - Flip the specified bit.
+ - set(uint32 bitIndex)
+ - Set the specified bit true.
+ - clear(uint32 bitIndex)
+ - Set the specified bit false.
+ - set(uint32 bitIndex, bool value)
+ - Set the specified bit to value.
+ - get(uint32 bitIndex)
+ - Return the state of the specified bit.
+ - clear()
+ - Set all bits to false.
+ - nextSetBit(uint32 fromIndex)
+ - Get the index of the next true bit beginning with the specified
+ bit.
+ - nextClearBit(uint32 fromIndex)
+ - Get the index of the next false bit beginning with the specified
+ bit.
+ - isEmpty()
+ - Return (false,true) if (at least one bit true, all bits are
+ false)
+ - cardinality()
+ - Return the number of true bits.
+ - operator&=(const BitSet& set)
+ - Performs a logical and of this target bit set with the argument bit
+ set. This bit set is modified so that each bit in it has the value true
+ if and only if it both initially had the value true and the
+ corresponding bit in the bit set argument also had the value.
+ - operator|=(const BitSet& set)
+ - Performs a logical or of this target bit set with the argument bit
+ set.
+ - operator^=(const BitSet& set)
+ - Performs a logical exclusive or of this target bit set with the
+ argument bit set.
+ - operator-=(const BitSet& set)
+ Clears all of the bits in this bitSet whose corresponding bit is
+ set in the specified bitSet.
+ - operator=(const BitSet &set)
+ - Assignment operator.
+ - or_and(const BitSet& set1, const
+ BitSet& set2)
+ - Perform AND operation on set1 and set2, and then OR this bitSet with
+ the result.
+ - operator==(const BitSet &set)
+ - Does this bitSet have the same values as the argument.
+ - operator!=(const BitSet &set)
+ - Is this bitSet different than the argument.
+ - toString(StringBuilder buffer)
+ - Show the current values of the bitSet.
+ - toString(StringBuilder buffer, int
+ indentLevel)
+ - Show the current values of the bitSet.
+
+
+ByteBuffer
+
+A ByteBuffer is used to serialize and deserialize primitive data. File
+byteBuffer.h is:
+class ByteBuffer {
+public:
+ ByteBuffer(int size = 32, int byteOrder = EPICS_BYTE_ORDER);
+ ~ByteBuffer();
+ ByteBuffer* clear();
+ ByteBuffer* flip();
+ ByteBuffer* rewind();
+ bool getBoolean();
+ int8 getByte();
+ int16 getShort();
+ int32 getInt();
+ int64 getLong();
+ float getFloat();
+ double getDouble();
+ void get(char* dst, int offset, int count);
+ ByteBuffer* put(const char* src, int offset, int count);
+ ByteBuffer* putBoolean(bool value);
+ ByteBuffer* putByte(int8 value);
+ ByteBuffer* putShort(int16 value);
+ ByteBuffer* putInt(int32 value);
+ ByteBuffer* putLong(int64 value);
+ ByteBuffer* putFloat(float value);
+ ByteBuffer* putDouble(double value);
+ inline int getSize() const;
+ inline int getArrayOffset() const;
+ inline int getPosition() const;
+ inline int getLimit() const;
+ inline int getRemaining() const;
+ inline int getByteOrder() const;
+ inline const char* getArray() const;
+ // TODO must define arrays
+private:
+};
+
+x
+
+Event
+
+This class provides coordinates activity between threads. One thread can
+wait for the event and the other signals the event.
+class Event : private NoDefaultMethods {
+public:
+ Event(bool full);
+ ~Event();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ void signal();
+ bool wait (); /* blocks until full */
+ bool wait ( double timeOut ); /* false if empty at time out */
+ bool tryWait (); /* false if empty */
+private:
+ epicsEventId id;
+};
+
+where
+
+ - Event
+ - The constructor. The initial value can be full or empty. The normal
+ first state is empty.
+ - getConstructDestructCallback
+ - Provides access to number of events that have been created and
+ destroyed.
+ - signal
+ - The event becomes full. The current or next wait will complete.
+ - wait
+ - Wait until event is full or until timeout. The return value is
+ (false,true) if the wait completed because event (was not, was) full. A
+ false value normally means that that a timeout occured. It is also
+ returned if an error occurs or because the event is being deleted.
+ - tryWait
+ - returns (false,true) if the event is (empty,full)
+
+
+Exception
+
+File epicsException.h describes:
+class BaseException : public std::exception {
+public:
+ BaseException(const char* message, const char* file,
+ int line, std::exception* cause = 0);
+ virtual ~BaseException();
+ virtual const char* what();
+ void toString(std::string& str, unsigned int depth = 0);
+ static inline void getStackTrace(
+ std::string* trace, unsigned int skip_frames = 0, unsigned int max_frames = 63)
+private:
+ // ...
+}
+
+x
+
+Executor
+
+An Executor is a thread that can execute commands. The user can request
+that a single command be executed.
+class ExecutorNode;
+
+class Command {
+public:
+ virtual void command() = 0;
+};
+
+class Executor : private NoDefaultMethods {
+public:
+ Executor(String threadName,ThreadPriority priority);
+ ~Executor();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ ExecutorNode * createNode(Command *command);
+ void execute(ExecutorNode *node);
+private:
+ class ExecutorPvt *pImpl;
+};
+
+Command is a class that must be implemented by the code that calls
+execute. It contains the single virtual method command, which is the command
+to execute.
+
+Executor has the methods:
+
+ - Executor
+ - The constructor. A thread name and priority must be specified.
+ - ~Executor
+ - The destructor. If any commands remain in the execute list they are
+ not called. All ExecutorNodes that have been created are deleted.
+ - getConstructDestructCallback
+ - Provides access to the number of executors that been created and
+ destroyed.
+ - createNode
+ - Create a ExecutorNode that can be passed to execute.
+ - execute
+ - Request that command be executed. If it is already on the run list
+ nothing is done.
+
+
+Linked List
+
+LinkedList implements a double linked list that requires a user to
+allocate the nodes. It is more efficent that std::list. linkedList.h is
+template that is both a complete description and definition. It uses
+linkedListVoid for method definitions. linkedListVoid is not\ meant for use
+except via linkedList. Note, however, that linkedListVoid does have both a
+node and a list static method getConstructDestructCallback, which allows
+access to how many nodes and lists have been created and destroyed.
+
+A node can only be on one list at a time but can be put, at different
+times, on different lists as long as they all hold the same type of objects.
+An exception is thrown if an attempt is made to put a node on a list if the
+node is already on a list.
+template <typename T>
+class LinkedList;
+
+template <typename T>
+class LinkedListNode : private LinkedListVoidNode {
+public:
+ LinkedListNode(T *object);
+ ~LinkedListNode();
+ T *getObject();
+ bool isOnList();
+};
+template <typename T>
+class LinkedList : private LinkedListVoid {
+public:
+ LinkedList();
+ ~LinkedList();
+ int getLength();
+ void addTail(LinkedListNode<T> *node);
+ void addHead(LinkedListNode<T> *node);
+ void insertAfter(LinkedListNode<T> *node,
+ LinkedListNode<T> *addNode);
+ void insertBefore(LinkedListNode<T> *node,
+ LinkedListNode<T> *addNode);
+ LinkedListNode<T> *removeTail();
+ LinkedListNode<T> *removeHead();
+ void remove(LinkedListNode<T> *listNode);
+ void remove(T *object);
+ LinkedListNode<T> *getHead();
+ LinkedListNode<T> *getTail();
+ LinkedListNode<T> *getNext(LinkedListNode<T> *node);
+ LinkedListNode<T> *getPrev(LinkedListNode<T> *node;
+ bool isEmpty();
+ bool contains(T *object);
+};
+
+LinkedListNode has the methods:
+
+ - LinkedListNode
+ - The constructor. The object must be specified.
+ - ~LinkedListNode
+ - The destructor.
+ - getObject
+ - Returns the nobject.
+ - isOnList
+ - returns (false,true) if the node (is not, is) on a list.
+
+
+LinkedList has the methods:
+
+ - LinkedList
+ - The constructor.
+ - ~LinkedList
+ - The destructor.
+ - getLength
+ - Get the numbet of nodes currently on the list.
+ - addTail
+ - Add a node to the end of the list. An exception is thrown if the node
+ is already on a list.
+ - addHead
+ - Add a node to the beginning of the list. An exception is thrown if
+ the node is already on a list.
+ - insertAfter
+ - Insert addNode after node. An exception is thrown if the addNode is
+ already on a list or if node is not on this list..
+ - insertBefore
+ - Insert addNode before node. An exception is thrown if the addNode is
+ already on a list or if node is not on this list.
+ - removeTail
+ - Remove and return the last node. Null is returned if the list is
+ empty.
+ - removeHead
+ - Remove and return the first node. Null is returned if the list is
+ empty.
+ - remove
+ - Remove the specified node or object. An exception is thrown if the
+ node is not on a list.
+ - getHead
+ - Get the first list node. Null is returned if the list is empty.
+ - getTail
+ - Get the last list node. Null is returned if the list is empty.
+ - getNext
+ - Get the node after node. An exception is thrown if node is not on
+ this list. Null is returned if the is node is the last node on the
+ list.
+ - getPrev
+ - Get the node before node. An exception is thrown if node is not on
+ this list. Null is returned if the is node is the first node on the
+ list.
+ - isEmpty
+ - Is the list empty.
+ - contains
+ - Does the list contain the specified object.
+
+
+Lock and Mutex
+
+lock.h contains:
+class Mutex {
+public:
+ Mutex();
+ ~Mutex();
+ void lock();
+ void unlock();
+private:
+};
+
+
+class Lock : private NoDefaultMethods {
+public:
+ explicit Lock(Mutex *pm);
+ ~Lock();
+private:
+};
+
+This is a complete description and definition of lock and mutex. These
+make it easy to have a lock that is as easy to use as Java synchronize. To
+protect some object just create a Mutex for the object and then in any method
+to be synchronized just have code like:
+class SomeClass {
+private
+ Mutex mutex;
+...
+public
+ SomeClass() : mutex(Mutex()) {}
+...
+ void method()
+ {
+ Lock xx(&mutex);
+ ...
+ }
+
+The method will take the lock when xx is created and release the lock when
+the current code block completes.
+
+Another example of Lock is initialization code that must initialize only
+once. This can be implemented as follows:
+ static void init(void) {
+ static Mutex mutex = Mutex();
+ Lock xx(&mutex);
+ if(alreadyInitialized) return;
+ // initialization
+ }
+
+Message Queue
+
+Definitions
+NOT IMPLEMENTED
+
+MessageQueue
+
+This is for use by code that wants to handle messages without blocking
+higher priority threads.
+
+A messageNode is a class with two public data members:
+
+ - message
+ - The message.
+ - messageType
+ - The message type.
+
+
+A messageQueue is an interface with methods:
+
+ - put
+ - Put a new message into the queue. False is returned if the queue was
+ full and true otherwise.
+ - isEmpty
+ - Is the queue empty?
+ - isFull
+ - Is the queue full?
+ - replaceFirst
+ - Replace the oldest member in the queue.
+ - replaceLast
+ - Replace the newest member in the queue.
+ - getClearOverrun
+ - Get the number of times replaceFirst or replaceLast have been called
+ since the last call to getClearOverrun. The internal counter is reset
+ to 0.
+
+
+MessageQueueFactory provides the public method:
+
+ - create
+ - Create a MessageQueue and return the interface.
+
+
+An example is:
+ private ExecutorNode executorNode;
+ ...
+ executorNode = executor.createNode(this);
+ ...
+
+ public void message(final String message, MessageType messageType) {
+ boolean execute = false;
+ synchronized(messageQueue) {
+ if(messageQueue.isEmpty()) execute = true;
+ if(messageQueue.isFull()) {
+ messageQueue.replaceLast(message, messageType);
+ } else {
+ messageQueue.put(message, messageType);
+ }
+ }
+ if(syncExec) {
+ iocExecutor.execute(executorNode);
+ }
+ }
+ ...
+ public run() { // handle messages
+ while(true) {
+ String message = null;
+ int numOverrun = 0;
+ synchronized(messageQueue) {
+ MessageNode messageNode = messageQueue.get();
+ numOverrun = messageQueue.getClearOverrun();
+ if(messageNode==null && numOverrun==0) break;
+ message = messageNode.message;
+ }
+ if(numOverrun>0) {
+ System.out.printf(String.format("%n%d missed messages&n", numOverrun));
+ }
+ if(message!=null) {
+ System.out.printf(String.format("%s%n",message));
+ }
+ }
+ }
+
+NoDefaultMethods
+
+If a class privately extends this class then the compiler can not create
+any of the following: default constructor, default copy constructror, or
+default assignment contructor.
+/* This is based on Item 6 of
+ * Effective C++, Third Edition, Scott Meyers
+ */
+ class NoDefaultMethods {
+ protected:
+ // allow by derived objects
+ NoDefaultMethods(){};
+ ~NoDefaultMethods(){}
+ private:
+ // do not implment
+ NoDefaultMethods(const NoDefaultMethods&);
+ NoDefaultMethods & operator=(const NoDefaultMethods &);
+ };
+
+pvType
+
+This provides typedefs for integers and String.
+typedef signed char int8;
+typedef short int16;
+typedef int int32;
+typedef long long int64;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
+
+typedef std::string String;
+typedef std::string * StringBuilder;
+typedef String* StringArray;
+
+where
+
+ - int8,...,int64
+ - Hopefully all modern C++ compilers will support these definitions. If
+ not then only pvType.h will require changes rather than user code.
+ - String
+ - Since std::string implements copy on write semantics, it can be used
+ for support for immutable strings. This is what pvData supports.
+ - StringBuilder
+ - Acts like the Java StringBuilder class.
+ - StringArray
+ - An array of Strings.
+
+
+Requester
+
+A PVField extends Requester. Requester is present so that when database
+errors are found there is someplace to send a message.
+enum MessageType {
+ infoMessage,warningMessage,errorMessage,fatalErrorMessage
+};
+
+extern StringArray messageTypeName;
+
+class Requester {
+public:
+ virtual String getRequesterName() = 0;
+ virtual void message(String message,MessageType messageType) = 0;
+};
+
+where
+
+
+ - MessageType
+ - Type of message.
+ - messageTypeName
+ - An array of strings of the message type names, i.e.
+ String("info"),String("warning"),String("error"),String("fatalError").
+ - getRequesterName
+ - Returns the requester name.
+ - message
+ - Gives a message to the requester.
+
+
+Serialize
+
+This is a helper class for serialization, which is required for sending
+and receiving pvData over the nerwork.
+class SerializeHelper : public NoDefaultMethods {
+public:
+ static void writeSize(int s, ByteBuffer* buffer,
+ SerializableControl* flusher);
+ static int readSize(ByteBuffer* buffer,
+ DeserializableControl* control);
+ static void serializeString(const String& value,
+ ByteBuffer* buffer,SerializableControl* flusher);
+ static void serializeSubstring(const String& value, int offset,
+ int count, ByteBuffer* buffer,
+ SerializableControl* flusher);
+ static String deserializeString(ByteBuffer* buffer,
+ DeserializableControl* control);
+private:
+};
+
+class SerializableControl {
+public:
+ virtual void flushSerializeBuffer() =0;
+ virtual void ensureBuffer(int size) =0;
+};
+class DeserializableControl {
+
+public:
+ virtual void ensureData(int size) =0;
+};
+class Serializable {
+public:
+ virtual void serialize(ByteBuffer *buffer,
+ SerializableControl *flusher) = 0;
+ virtual void deserialize(ByteBuffer *buffer,
+ DeserializableControl *flusher) = 0;
+};
+class BitSetSerializable {
+public:
+ virtual void serialize(ByteBuffer *buffer,
+ SerializableControl *flusher,BitSet *bitSet) = 0;
+ virtual void deserialize(ByteBuffer *buffer,
+ DeserializableControl *flusher,BitSet *bitSet) = 0;
+};
+class SerializableArray : public Serializable {
+public:
+ virtual void serialize(ByteBuffer *buffer,
+ SerializableControl *flusher, int offset, int count) = 0;
+};
+
+where
+
+ - writeSize
+ - Serialize the size.
+ - readSize
+ - Deserialize the size.
+ - serializeString
+ - Serialize a String.
+ - serializeSubstring
+ - Serialize a substring.
+ - deserializeString
+ - Deserialize a string.
+
+
+The following interfaces are called by pvAccess for transporting data over
+the network. The abstract and base classes ensure that these methods are
+properly implemented.
+x
+
+x
+
+Show Constructors and Destructors
+
+This is a facility that allows a class to report how many objects of that
+class have been created and destroyed. This can help find memory leaks.
+typedef int64 (*getTotal)();
+
+class ConstructDestructCallback : private NoDefaultMethods {
+public:
+ ConstructDestructCallback(
+ String name,
+ getTotal construct,
+ getTotal destruct,
+ getTotal reference);
+ String getConstructName();
+ int64 getTotalConstruct();
+ int64 getTotalDestruct();
+ int64 getTotalReferenceCount();
+private:
+ ~ConstructDestructCallback();
+ String name;
+ getTotal construct;
+ getTotal destruct;
+ getTotal reference;
+};
+
+class ShowConstructDestruct : private NoDefaultMethods {
+public:
+ static void constuctDestructTotals(FILE *fd);
+ static void registerCallback(ConstructDestructCallback *callback);
+private:
+ ShowConstructDestruct();
+ friend ShowConstructDestruct* getShowConstructDestruct();
+};
+
+extern ShowConstructDestruct* getShowConstructDestruct();
+
+ConstructDestructCallback is implemented by a class that keeps track of
+how many instances of the class has been created and how many destroyed. The
+clas must implement this class and register it with ShowConstructDestruct. To
+see an example of how this is implemented look at misc/thread.cpp.
+
+Classes that implement this class also include a static method that makes
+ConstructDestructCallback available to code that wants look at the memory
+usage of a particular class.
+
+ShowConstructDestruct is the class that reports the memory uasge of all
+registered classes. It can be called as folows:
+ getShowConstructDestruct()->constuctDestructTotals(fd);
+
+Status
+
+Status provides a way to pass status back to client code. It is new and
+not currently used by pvData but may be in the future. It is used by code
+that uses pvData.
+NOT IMPLEMENTED
+
+The Status methods are:
+
+ - StatusType
+ - An enum for the status type.
+ - getType
+ - Get the statusType.
+ - getMessage
+ - Get a message explaining the error.
+ - getStackDump
+ - Get a stack dump.
+
+
+The StatusCreate methods are:
+
+ - getStatusOK
+ - Get a singleton that returns StatusType.OK and a null message and
+ stackDump.
+ - createStatus
+ - Create a new Status.
+ - deserializeStatus
+ - Use this method instead of Status.deserialize(), since this allows OK
+ status optimization.
+
+
+Thread
+
+ThreadPriority
+enum ThreadPriority {
+ lowestPriority,
+ lowerPriority,
+ lowPriority,
+ middlePriority,
+ highPriority,
+ higherPriority,
+ highestPriority
+};
+
+class ThreadPriorityFunc {
+public:
+ static unsigned int const * const getEpicsPriorities();
+ static int getEpicsPriority(ThreadPriority threadPriority);
+};
+
+Thread
+class Runnable {
+public:
+ virtual void run() = 0;
+};
+
+class Thread;
+
+class Thread : private NoDefaultMethods {
+public:
+ Thread(String name,ThreadPriority priority,Runnable *runnableReady);
+ ~Thread();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ String getName();
+ ThreadPriority getPriority();
+ static void showThreads(StringBuilder buf);
+ static void sleep(double seconds);
+private:
+};
+
+Runnable must be implement by code that wants to be run via a thread. It
+has one virtual method: run. Run is the code that is run as a thread. When
+run compeletes it can not be restarted. If code wants to delete a thread then
+it MUST arrange that the run returns before the thread can be deleted. An
+exception is thrown if run remains active when delete is called.
+
+Thread has the methods:
+
+ - Thread
+ - The constructor. A thread name and priority must be specified. The
+ run methods of runnable is executed. When the run methods returns the
+ thread will no longer be active but the client code must still delete
+ the thread.
+ - ~Thread
+ - The destructor. This is called as the result of:
+
delete pthread;
+
+ - getConstructDestructCallback
+ - Provides access to the number of threads that been created and
+ destroyed.
+ - getName
+ - Get the thread name.
+ - getPriority
+ - Get the thread priority.
+ - showThreads
+ - Get a String that has the name and priority of all currently
+ allocated threads.
+ - sleep
+ - Make the current thread sleep for the specified number of
+ seconds.
+
+
+Time Function Call
+
+TimeFunction is a facility that measures the average number of seconds a
+function call requires. When timeCall is called, it calls function in a loop.
+It starts with a loop of one iteration. If the total elapsed time is less
+then .1 seconds it increases the number of iterrations by a factor of 10. It
+keeps repeating until the elapsed time is greater than .1 seconds. It returns
+the average number of seconds per call.
+class TimeFunctionRequester {
+public:
+ virtual void function() = 0;
+};
+
+class TimeFunction : private NoDefaultMethods {
+public:
+ TimeFunction(TimeFunctionRequester *requester);
+ ~TimeFunction();
+ double timeCall();
+private:
+ TimeFunctionRequester *requester;
+};
+
+TimeFunctionRequester must be implemented by code that wants to time how
+long a function takes. It has the single method:
+
+ - function
+ - This is the function.
+
+
+TimeFunction has the methods:
+
+ - TimeFunction
+ - Constructor.
+ - ~TimeFunction
+ - Destructor.
+ - timeCall
+ - Time how long it takes to execute the function. It starts by calling
+ the function one time. If it takes < 1 seconds to doubles the number
+ of times to call the function. It repeats this until it takes at least
+ one second to call it ntimes.
+
+
+Timer
+
+This provides a general purpose timer. It allows a user callback to be
+called after a delay or periodically.
+class TimerCallback {
+public:
+ virtual void callback() = 0;
+ virtual void timerStopped() = 0;
+};
+
+class TimerNode : private NoDefaultMethods {
+public:
+ TimerNode(TimerCallback *timerCallback);
+ ~TimerNode();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ void cancel();
+ bool isScheduled();
+private:
+};
+
+class Timer : private NoDefaultMethods {
+public:
+ Timer(String threadName, ThreadPriority priority);
+ ~Timer();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ void scheduleAfterDelay(TimerNode *timerNode,double delay);
+ void schedulePeriodic(TimerNode *timerNode,double delay,double period);
+private:
+};
+
+TimerCallback must be implemented by the user. It has the following
+methods:
+
+ - callback
+ - This is called when a timer expires. This is called with no locks
+ held. When called a delay timer is no longer on the queue but a
+ periodioc timer is on a queue. Thus the callback for a delay timer can
+ issue a new schedule request but a periodic timer must not. Note the
+ explaination of TimerNode.cancel below.
+ - timerStopped
+ - Timer.stop was called when a timer request was queued. or if the
+ timer is stopped and a schedule request is made.
+
+
+In order to schedule a callback client code must allocate a TimerNode It
+can be used to schedule multiple callbacks. It has the methods:
+
+ - TimerNode
+ - The constructor. User code must create a TimeNode in order to call a
+ schedule method.
+ - ~TimerNode
+ - The destructor. This is called as a result of the client calling:
+
delete timerNode;
+
+ - getConstructDestructCallback
+ - Provides access to the number of timerNodes that been created and
+ destroyed.
+ - cancel
+ - This is called to cancel a timer request. If a callback has been
+ dequeued but the callback not called when cancel is called then a
+ callback may still happen. New schedule requests can be made after a
+ cancel request has been made.
+ - isScheduled
+ - Is the timerNode scheduled to be called.
+
+
+Timer has the methods:
+
+ - Timer
+ - The consttructor.
+ - ~Timer
+ - The destructor. The queue is emptied and TimerCallback.timerStopped
+ is called for each element of the queue.
+ - getConstructDestructCallback
+ - Provides access to the number of timers that been created and
+ destroyed.
+ - scheduleAfterDelay
+ - A request to schedule a callback after a delay specified in
+ seconds.
+ - schedulePeriodic
+ - Schedule a periodic callback.
+
+
+TimeStamp
+
+TimeStamp is a class for accessing a timeStamp that consists of the number
+of seconds since the epoch and the number of nanoseconds within the current
+second. The epoch is the posix epoch which is Jan 1, 1970 at 00:00:00
+Universal Time Coordinated.
+
+The seconds since the epoch is kept as an int64 and the nano seconds is
+kept as in int32.
+
+The implementation of some of the methods (getCurrent, fromTime_t, and
+toTime_t) use epicsTime from EPICS base and will thus have a problem when the
+epics secPastEpoch overflows, which will happen in about 2126.
+
+The TimeStamp class provides arithmetic operations on time stamps. The
+result is always kept in normalized form, which means that the nano second
+portion is 0≤=nano<nanoSecPerSec. Note that it is OK to have timeStamps
+for times previous to the epoch.
+
+TimeStamp acts like a primitive. It can be allocated on the stack and the
+compiler is free to generate default methods, i.e. copy constructor,
+assignment constructor, and destructor.
+
+One use for TimeStamp is to time how long a section of code takes to
+execute. This is done as follows:
+ TimeStamp startTime;
+ TimeStamp endTime;
+ ...
+ startTime.getCurrent();
+ // code to measure time
+ endTime.getCurrent();
+ double time = TimeStamp::diff(endTime,startTime);
+
+TimeStamp is described as:
+extern int32 milliSecPerSec;
+extern int32 microSecPerSec;
+extern int32 nanoSecPerSec;
+extern int64 posixEpochAtEpicsEpoch;
+
+class TimeStamp {
+public:
+ TimeStamp();
+ TimeStamp(int64 secondsPastEpoch,int32 nanoSeconds = 0);
+ //default constructors and destructor are OK
+ //This class should not be extended
+ void normalize();
+ void fromTime_t(const time_t &);
+ void toTime_t(time_t &) const;
+ int64 getSecondsPastEpoch() const;
+ int64 getEpicsSecondsPastEpoch() const;
+ int32 getNanoSeconds() const;
+ void put(int64 secondsPastEpoch,int32 nanoSeconds = 0);
+ void put(int64 milliseconds);
+ void getCurrent();
+ double toSeconds() const ;
+ bool operator==(TimeStamp const &) const;
+ bool operator!=(TimeStamp const &) const;
+ bool operator<=(TimeStamp const &) const;
+ bool operator< (TimeStamp const &) const;
+ bool operator>=(TimeStamp const &) const;
+ bool operator> (TimeStamp const &) const;
+ static double diff(TimeStamp const & a,TimeStamp const & b);
+ TimeStamp & operator+=(int64 seconds);
+ TimeStamp & operator-=(int64 seconds);
+ TimeStamp & operator+=(double seconds);
+ TimeStamp & operator-=(double seconds);
+ int64 getMilliseconds(); //milliseconds since epoch
+private:
+};
+
+TimeStamp has the methods:
+
+ - Timer
+ - The default constructor sets both seconds and nano seconds to 0. The
+ other constructor shown above will call normalize.
+ - normalize
+ - Adjust seconds and nano seconds so that
+ 0<=nano<nanoSecPerSec
+ - fromTime_t
+ - Set the timeStamp value from "time_t", which is defined
+ <ctime>, i.e. by the standard C++ library and also as part of
+ standard C.
+ - toTime_t
+ - Convert the timeStamp to "time_t". From time_t, using that standard
+ C++ library <ctime> it is easy to get a "struct tm" that has the
+ the time broken into parts. For example:
+
TimeStamp current;
+ current.getCurrent();
+ time_t tt;
+ current.toTime_t(tt);
+ struct tm ctm;
+ memcpy(&ctm,localtime(&tt),sizeof(struct tm));
+ fprintf(auxfd,
+ "%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s\n",
+ ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
+ ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
+ current.getNanoSeconds(),
+ (ctm.tm_isdst==0) ? "false" : "true");
+ prints something like:
+ 2010.12.01 07:39:48 807264972 nanoSeconds isDst false
+
+ - getSecondsPastEpoch
+ - Gets the number of seconds since Jan 1 1970 UTC.
+ - getEpicsSecondsPastEpoch
+ - Gets the number of seconds since Jan 1 1990 UTC.
+ - getNanoSeconds
+ - Get the number of nano seconds. This is always
+ 0<=value<nanoSecPerSec
+ - put
+ - Set the timeStamp value. The result will always be normalized.
+ - getCurrent
+ - Get the current time.
+ - toSeconds
+ - Get the value as a double. It is the number of seconds since the
+ epoch.
+ - operator==
+ - Compare equal.
+ - operator!=
+ - Compare not equal.
+ - operator<=
+ - Is value <= arg.
+ - operator<
+ - Is value < arg.
+ - operator>=
+ - Is value >= arg.
+ - operator>
+ - Is value > arg.
+ - diff
+ - The result is (a-b) in seconds.
+ - operator+=
+ - Add the argument to the timeStamp. The argument can be an integer or
+ a double. The result will be normalized.
+ - operator-=
+ - Subtract the argument from the timeStamp. The argument can be an
+ integer or a double. The result will be normalized.
+ - getMilliseconds
+ - Get the timeStamp as number of milliseconds since the epoch.
+
+
+Queue
+
+This provides a queue which has an immutable capacity, which is specified
+when the queue is created. When the queue is full the user code is expected
+to keep using the current el;ement until a new free element becomes avalable.
+This is used by pvData.monitor.
+NOT IMPLEMENTED
+
+A queueCreate instance is created via a call like the following:
+ QueueCreate<MyObject> queueCreate = new QueueCreate<MyObject>();
+
+Once a queueCreate is available a queue instance is created via code like
+the following:
+Queue<MyObject> queue create(MyObject[] myObjects) {
+ QueueElement<MyObject>[] queueElements = new QueueElement[length];
+ for(int i=0; i<length; i++) {
+ QueueElement<MonitorElement> queueElement =
+ queueCreate.createQueueElement(myObjects[i);
+ queueElements[i] = queueElement;
+ }
+ return queueCreate.create(queueElements);
+}
+
+The queue methods are:
+
+ - clear
+ - Make the queue empty.
+ - getNumberFree
+ - Get the number of fee elements in the queue.
+ - capacity
+ - Get the capacity, i.e. the maximun number of elements the queue can
+ hold.
+ - getFree
+ - Get the next free element. Null is returned if no free elements are
+ available. If a non null value is returned then the element belongs to
+ the caller until setUsed is called.
+ - setUsed
+ - Set a queue element used. This must be the element returned by the
+ last call to getFree.
+ - getUsed
+ - Get the next used element of null if no more used elements are
+ available.
+ - releaseUsed
+ - Set a queue element free. This must be the element returned by the
+ last call to getUsed.
+
+
+A producer calls getFree and setUsed via code like the following:
+ MyObject getFree() {
+ QueueElement<MyObject> queueElement = queue.getFree();
+ if(queueElement==null) return null;
+ return queueElement.getObject();
+ }
+
+A consumer calls getUsed and releaseUsed via code like the following:
+ while(true) {
+ QueueElement<MyObject> queueElement = queue.getUsed();
+ if(queueElement==null) break;
+ MyObject myObject = queueElement.getObject();
+ // do something with myObject
+ queue.releaseUsed(queueElement);
+ }
+
+
+PV - User Description
+
+
+Overview
+
+Directory pvDataApp/pv has header files that completely describe pvData.
+The implementation is provided in directory pvDataApp/factory. Test programs
+appears on pvDataApp/pvTest.
+
+A PVStructure is a field that contains an array of subfields. Each field
+has code for accessing the field. The interface for each field is PVField or
+an interface that extends PVField. Each field also has an introspection
+interface, which is Field or an extension of Field. This section describes
+the complete set of data and introspection interfaces for pvData.
+
+A class FieldCreate creates introspection objects. A class PVDataCreate
+createsdata objects. A class Convert provides a rich set of methods for
+converting and copying data between fields.
+
+Directory pvDataApp/pv has the following header files:
+
+ - pvIntrospect.h
+ - A cpmplete description of the introspection interfaces.
+ - pvData.h
+ - A complete description of the data interfaces.
+ - convert.h
+ - The facility that converts between data fields.
+ - standardField.h
+ - Provides access to introspection interfaces for standard field like
+ timeStamp, alarm, etc.
+ - standardPVField.h
+ - Cteates data interfaces for standard data fields like timeStamp,
+ alarm, etc.
+
+
+Process Variable Reflection
+
+This subsection describes pvIntrospect.h
+
+Given a pvname, which consists of a record name and field name, it is
+possible to introspect the field without requiring access to data. The
+reflection and data interfaces are separate because the data may not be
+available. For example when a client connects to a PV, the client library can
+obtain the reflection information without obtaining any data. Only when a
+client issues an I/O request will data be available. This separation is
+especially important for arrays and structures so that a client can discover
+the type without requiring that a large array or structure be transported
+over the network.
+
+Type
+
+The types are defined by the Java definitions:
+enum Type {
+ scalar,
+ scalarArray,
+ structure,
+ structureArray;
+};
+class TypeFunc {
+public:
+ static void toString(StringBuilder buf,const Type type);
+};
+
+
+enum ScalarType {
+ pvBoolean,
+ pvByte, pvShort, pvInt, pvLong,
+ pvFloat,pvDouble,
+ pvString;
+};
+class ScalarTypeFunc {
+public:
+ static bool isInteger(ScalarType type);
+ static bool isNumeric(ScalarType type);
+ static bool isPrimitive(ScalarType type);
+ static ScalarType getScalarType(String value);
+ static void toString(StringBuilder buf,ScalarType scalarType);
+};
+
+Type is one of the
+following:
+
+ - scalar
+ - A scalar of one of the scalar types.
+ - scalarArray
+ - An array where every element has the same scalar type.
+ - structure
+ - A structure where each field can have a dfferent type.
+ - structureArray
+ - An array where each element is a structure. Each element has the same
+ structure introspection interface.
+
+
+ScalarType is one of the
+following:
+
+ - pvBoolean
+ - Has the value false or true.
+ - pvByte
+ - A signed 8 bit integer.
+ - pvShort
+ - A signed 16 bit integer.
+ - pvInt
+ - A signed 32 bit integer.
+ - pvLong
+ - A signed 64 bit integer.
+ - pvFloat
+ - A IEEE float.
+ - pvDouble
+ - A IEEE double,
+ - pvString
+ - An immutable string.
+
+
+TypeFunction is a set of
+convenience methods for Type
+
+ - toString
+ - Convert the type to a string.
+
+
+ScalarTypeFunction is a set of
+convenience methods for ScalarType
+
+ - isInteger
+ - Is the scalarType an integer type, i.e. one of pvByte,...pvlong.
+ - isNumeric
+ - Is the scalarType numeric, i.e. pvByte,...,pvDouble.
+ - isPrimitive
+ - Is the scvalarType primitive, i.e. not pvString
+ - getScalarType
+ - Given a string of the form String("boolean"),...,String("string")
+ return the scalarType.
+ - toString
+ - Convert the scalar type to a string.
+
+
+Reflection
+
+This section defines the complete set of Java PV reflection interfaces.
+
+class Field : private NoDefaultMethods {
+public:
+ virtual ~Field();
+ Field(String fieldName,Type type);
+ static ConstructDestructCallback *getConstructDestructCallback();
+ int getReferenceCount() const;
+ String getFieldName() const;
+ Type getType() const;
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+};
+
+class Scalar : public Field{
+public:
+ Scalar(String fieldName,ScalarType scalarType);
+ virtual ~Scalar();
+ ScalarType getScalarType() const {return scalarType;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+};
+class ScalarArray : public Field{
+public:
+ ScalarArray(String fieldName,ScalarType scalarType);
+ virtual ~ScalarArray();
+ ScalarType getElementType() const {return elementType;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+};
+
+class StructureArray : public Field{
+public:
+ StructureArray(String fieldName,StructureConstPtr structure);
+ virtual ~StructureArray();
+ StructureConstPtr getStructure() const {return pstructure;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+};
+
+class Structure : public Field {
+public:
+ Structure(String fieldName, int numberFields,FieldConstPtrArray fields);
+ virtual ~Structure();
+ int getNumberFields() const {return numberFields;}
+ FieldConstPtr getField(String fieldName) const;
+ int getFieldIndex(String fieldName) const;
+ FieldConstPtrArray getFields() const {return fields;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+};
+
+class FieldCreate : NoDefaultMethods {
+public:
+ FieldConstPtr create(String fieldName,FieldConstPtr field) const;
+ ScalarConstPtr createScalar(String fieldName,ScalarType scalarType) const;
+ ScalarArrayConstPtr createScalarArray(String fieldName,
+ ScalarType elementType) const;
+ StructureConstPtr createStructure (String fieldName,
+ int numberFields,FieldConstPtrArray fields) const;
+ StructureArrayConstPtr createStructureArray(String fieldName,
+ StructureConstPtr structure) const;
+private:
+};
+
+extern FieldCreate * getFieldCreate();
+
+The above definitions support the following:
+
+ - Field
+ - A field:
+
+ - Has a name.
+ - Has a Type.
+ - Can be converted to a string.
+
+
+ - Scalar
+ - A scalar has a scalarType
+ - ScalarArray
+ - The element type is a scalarType
+ - StructureArray
+ - The field holds PVStructure[]. Each element has the same Structure
+ interspection interface. A client can only get/put entire PVStructure
+ elements NOT subfields of array elements.
+ - Structure
+ - Has fields that can be any of the supported types.
+ - FieldCreate
+ - This is an interface that provides methods to create introspection
+ interfaces. A factory is provides to create FieldCreate.
+ - getFieldCreate
+ - Gets a pointer to the single instance of FieldCreate.
+
+
+Standard Fields
+
+The file standardField.h has a class description for getting Field objects
+for standard fields. For each type of standard object two methods are
+defined: one with no properties and with properties. The property field is a
+comma separated string of property names of the following: alarm, timeStamp,
+display, control, and valueAlarm. An example is "alarm,timeStamp,valueAlarm".
+The method with properties creates a structure with fields named fieldName
+and each of the property names. Each property field is a structure defining
+the property. The details about each property is given in the section named
+"Property". For example the call:
+ StructureConstPtr example = standardField->scalar(
+ String("value"),
+ pvDouble,
+ String("value,alarm,timeStamp"));
+
+Will result in a Field definition that has the form:
+structure example
+ double value
+ structure alarm
+ structure severity
+ int index
+ string[] choices
+ structure timeStamp
+ long secondsPastEpoch
+ int nanoSeconds
+
+In addition there are methods that create each of the property structures,
+i.e. the methods named: alarm, .... enumeratedAlarm."
+
+pvIntrospect.h contains:
+class StandardField : private NoDefaultMethods {
+public:
+ StandardField();
+ ~StandardField();
+ ScalarConstPtr scalar(String fieldName,ScalarType type);
+ StructureConstPtr scalar(String fieldName,
+ ScalarType type,String properties);
+ ScalarArrayConstPtr scalarArray(String fieldName,
+ ScalarType elementType);
+ StructureConstPtr scalarArray(String fieldName,
+ ScalarType elementType, String properties);
+ StructureArrayConstPtr structureArray(String fieldName,
+ StructureConstPtr structure);
+ StructureConstPtr structureArray(String fieldName,
+ StructureConstPtr structure,String properties);
+ StructureConstPtr structure(String fieldName,
+ int numFields,FieldConstPtrArray fields);
+ StructureConstPtr enumerated(String fieldName,
+ StringArray choices);
+ StructureConstPtr enumerated(String fieldName,
+ StringArray choices, String properties);
+ ScalarConstPtr scalarValue(ScalarType type);
+ StructureConstPtr scalarValue(ScalarType type,String properties);
+ ScalarArrayConstPtr scalarArrayValue(ScalarType elementType);
+ StructureConstPtr scalarArrayValue(ScalarType elementType,
+ String properties);
+ StructureArrayConstPtr structureArrayValue(StructureConstPtr structure);
+ StructureConstPtr structureArrayValue(StructureConstPtr structure,
+ String properties);
+ StructureConstPtr structureValue(
+ int numFields,FieldConstPtrArray fields);
+ StructureConstPtr enumeratedValue(StringArray choices);
+ StructureConstPtr enumeratedValue(StringArray choices,
+ String properties);
+ StructureConstPtr alarm();
+ StructureConstPtr timeStamp();
+ StructureConstPtr display();
+ StructureConstPtr control();
+ StructureConstPtr booleanAlarm();
+ StructureConstPtr byteAlarm();
+ StructureConstPtr shortAlarm();
+ StructureConstPtr intAlarm();
+ StructureConstPtr longAlarm();
+ StructureConstPtr floatAlarm();
+ StructureConstPtr doubleAlarm();
+ StructureConstPtr enumeratedAlarm();
+private:
+ static void init();
+};
+
+extern StandardField * getStandardField();
+
+Where
+
+ - scalar
+ - Create a scalar with the specified scalar type and name. If
+ properties are specified then a structure will be created with the
+ first element being a scalar with the specified scalar type and name
+ value. The other fields in the structure will be the corresponding
+ property structures.
+ - scalarArray
+ - Create a scalarArray with each element having the specified scalar
+ type and name. If properties are specified then a structure will be
+ created with the first element being a scalarArray with name value. The
+ other fields in the structure will be the corresponding property
+ structures.
+ - structureArray
+ - Create a structureArray with the specified structure interface and
+ name. If properties are specified then a structure will be created with
+ the first element being a structureArray with the specified structure
+ interface and name value. The other fields in the structure will be the
+ corresponding property structures.
+ - structure
+ - Create a structure with the specified name and fields specified by
+ numFields and fields. If properties are specified then a structure will
+ be created with the first element being a structure with the name value
+ and fields specified by numFields and fields. The other fields in the
+ structure will be the corresponding property structures.
+ - enumerated
+ - Create a structure with the specified name and fields for an
+ enumerated structure. If properties are specified then a structure will
+ be created with the first element being a structure with the name value
+ and fields for an enumerated structure. The other fields in the
+ structure will be the corresponding property structures.
+ - scalarValue
+ - scalarArrayValue
+ - structureArrayValue
+ - structureValue
+ - enumeratedValue
+ - These are all like the version without the "Value" suffix except that
+ the field name will always be "value"
+ - alarm
+ - timeStamp
+ - display
+ - control
+ - booleanAlarm
+ - byteAlarm
+ - shortAlarm
+ - intAlarm
+ - longAlarm
+ - floatAlarm
+ - doubleAlarm
+ - enumeratedAlarm
+ - The above provide introspection interfaces fot standard properties.
+ See the section on Properties for a description of how these are
+ defined.
+
+
+PVField - Data Interfaces
+
+This section defines the Java Interfaces for accessing the data within a
+PV record.
+
+PVField
+
+PVField is the base interface for accessing data. A data structure
+consists of a top level PVStructure. Every field of every structure of every
+top level structure has a PVField associated with it.
+class PostHandler {
+public:
+ virtual void postPut() = 0;
+};
+
+
+class PVField
+: public Requester,
+ public Serializable,
+ private NoDefaultMethods
+{
+public:
+ virtual ~PVField();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ virtual void setRequester(Requester *prequester);
+ int getFieldOffset() ;
+ int getNextFieldOffset() ;
+ int getNumberFields() ;
+ PVAuxInfo * getPVAuxInfo();
+ bool isImmutable() ;
+ void setImmutable();
+ FieldConstPtr getField() ;
+ PVStructure * getParent() ;
+ void replacePVField(PVField * newPVField);
+ void renameField(String newName);
+ void postPut() ;
+ void setPostHandler(PostHandler *postHandler);
+ virtual void toString(StringBuilder buf) ;
+ virtual void toString(StringBuilder buf,int indentLevel) ;
+ virtual bool operator==(PVField &pv) = 0;
+ virtual bool operator!=(PVField &pv) = 0;
+protected:
+ PVField(PVStructure *parent,FieldConstPtr field);
+ void replaceStructure(PVStructure *pvStructure);
+private:
+};
+
+PostHandler is a class that
+must bed implemented by any code that calls setPostHandler. It's single
+virtual method. postPut is called
+whenever PVField::postPut is
+called.
+
+Requester,Serializable, and
+NoDefaultMethods were described in a previous section.
+
+The public methods for PVField
+are:
+
+ - ~PVField
+ - destructor which must be called by whatever created the PVfield via a
+ call to one of the methods of PVDataCreate
+ - getConstructDestructCallback
+ - Provides access to the number of timers that been created and
+ destroyed.
+ - setRequester
+ - Sets a requester to be called when message or getRequesterName are
+ called.
+ - getFieldOffset
+ - Get offset of the PVField field within top level structure. Every
+ field within the PVStructure has a unique offset. The top level
+ structure has an offset of 0. The first field within the structure has
+ offset equal to 1. The other offsets are determined by recursively
+ traversing each structure of the tree.
+ - getNextFieldOffset
+ - Get the next offset. If the field is a scalar or array field then
+ this is just offset + 1. If the field is a structure it is the offset
+ of the next field after this structure. Thus (nextOffset - offset) is
+ always equal to the total number of fields within the field.
+ - getNumberFields
+ - Get the total number of fields in this field. This is nextFieldOffset
+ - fieldOffset.
+ - getPVAuxInfo
+ - Get the PVAuxInfo for this field. PVAuxInfo is described below.
+ - isImmutable
+ - Is the field immutable?
+ - setImmutable
+ - Make the field immutable. Once a field is immutable it can never be
+ changed since there is no method to again make it mutable. This is an
+ important design decision since it allows immutable array fields to
+ share the internal primitive data array.
+ - getField
+ - Get the reflection interface for the data.
+ - getParent
+ - Get the interface for the parent or null if this is the top level
+ PVStructure.
+ - replacePVField
+ - Replace this PVField. This is called by support code that wants to
+ replace the default implementation of a data field with it's own
+ implementation.
+ - renameField
+ - Rename the field name.
+ - postPut
+ - If this field is a field of a record pvRecordField.postPut() is
+ called. If not a field of a record nothing happens.
+ - toString
+ - Converts the field data to a string. This is mostly for debugging
+ purposes.
+
+
+PVAuxInfo
+
+AuxInfo (Auxillary Information) is information about a field that is
+application specific. It will not be available outside the application that
+implements the database. In particular it will not be made available to
+Channel Access. It is used by the database itself to override the default
+implementation of fields. The JavaIOC uses it for attaching support code.
+Database Configuration and other tools can use it for configuration
+information. Each Field and each PVField can have have an arbitrary number of
+auxInfos. An auxInfo is a (key,PVScalar) pair where key is a string.
+class PVAuxInfo : private NoDefaultMethods {
+public:
+ PVAuxInfo(PVField *pvField);
+ ~PVAuxInfo();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ PVField * getPVField();
+ PVScalar * createInfo(String key,ScalarType scalarType);
+ PVScalarMap getInfos();
+ PVScalar * getInfo(String key);
+ void toString(StringBuilder buf);
+ void toString(StringBuilder buf,int indentLevel);
+private:
+};
+
+where
+
+ - getPVField
+ - Get the PVField to which this PVAuxInfo is attached.
+ - createInfo
+ - Create a new PVScalar of type scalarType.
+ - getInfos
+ - Get a map of all the auxInfos.
+ - getInfo
+ - Get the PVScalar with the specified key.
+ - toString
+ - Print all the auxInfos
+
+
+PVScalar and extensions
+class PVScalar : public PVField {
+public:
+ virtual ~PVScalar();
+ ScalarConstPtr getScalar() ;
+protected:
+ PVScalar(PVStructure *parent,ScalarConstPtr scalar);
+};
+
+Primitive PVField types
+
+The interfaces for primitive data types are:
+class PVBoolean : public PVScalar {
+public:
+ virtual ~PVBoolean();
+ virtual bool get() = 0;
+ virtual void put(bool value) = 0;
+protected:
+ PVBoolean(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVByte : public PVScalar {
+public:
+ virtual ~PVByte();
+ virtual int8 get() = 0;
+ virtual void put(int8 value) = 0;
+protected:
+ PVByte(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVShort : public PVScalar {
+public:
+ virtual ~PVShort();
+ virtual int16 get() = 0;
+ virtual void put(int16 value) = 0;
+protected:
+ PVShort(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+class PVInt : public PVScalar{
+public:
+ virtual ~PVInt();
+ virtual int32 get() = 0;
+ virtual void put(int32 value) = 0;
+protected:
+ PVInt(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVLong : public PVScalar {
+public:
+ virtual ~PVLong();
+ virtual int64 get() = 0;
+ virtual void put(int64 value) = 0;
+protected:
+ PVLong(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVFloat : public PVScalar {
+public:
+ virtual ~PVFloat();
+ virtual float get() = 0;
+ virtual void put(float value) = 0;
+protected:
+ PVFloat(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+class PVDouble : public PVScalar {
+public:
+ virtual ~PVDouble();
+ virtual double get() = 0;
+ virtual void put(double value) = 0;
+protected:
+ PVDouble(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVString : public PVScalar {
+public:
+ virtual ~PVString();
+ virtual String get() = 0;
+ virtual void put(String value) = 0;
+protected:
+ PVString(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+PVArray and Extensions
+
+PVArray is the base interface
+for all the other PV Array interfaces. It extends PVField and provides the
+additional methods:
+class PVArray : public PVField, public SerializableArray {
+public:
+ virtual ~PVArray();
+ int getLength() ;
+ void setLength(int length);
+ int getCapacity() ;
+ bool isCapacityMutable() ;
+ void setCapacityMutable(bool isMutable);
+ virtual void setCapacity(int capacity) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVArray(PVStructure *parent,FieldConstPtr field);
+ void setCapacityLength(int capacity,int length);
+private:
+ class PVArrayPvt * pImpl;
+};
+
+ - getLength
+ - Get the current length. This is less that or equal to the
+ capacity.
+ - setLength
+ - Set the length. If the PVField is not mutable then an exception is
+ thrown. If this is greater than the capacity setCapacity is called.
+ - getCapacity
+ - Get the capacity, i.e. this is the sized of the underlying data
+ array.
+ - setCapacity
+ - Set the capacity. The semantics are implementation dependent but
+ typical semantics are as follows: If the capacity is not mutable an
+ exception is thrown. A new data array is created and data is copied
+ from the old array to the new array.
+ - isCapacityMutable
+ - Is the capacity mutable
+ - setCapacityMutable
+ - Specify if the capacity can be changed.
+
+
+PVArray Extensions
+
+The interface for each array type has get and put methods which have the
+same arguments except for the data type. For example PVDoubleArray is:
+class DoubleArrayData {
+public:
+ DoubleArrayData(){}
+ ~DoubleArrayData(){};
+ DoubleArray data;
+ int offset;
+};
+
+class PVDoubleArray : public PVScalarArray {
+public:
+ virtual ~PVDoubleArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, DoubleArrayData *data) = 0;
+ virtual int put(int offset,int length, DoubleArray from, int fromOffset) = 0;
+ virtual void shareData(DoubleArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+Get "exposes" it's internal array by setting data.data and data.offset.
+The caller is responsible for copying the array elements. This violates the
+principle that objects should not expose their internal data but is done for
+efficency. For example it makes it possible to copy between arrays with
+identical element types via a call to System.arraycopy without requiring an
+intermediate array.
+
+Both get and put return the number of elements actually transfered. The
+arguments are:
+
+ - offset
+ - The offset in the PV array.
+ - len
+ - The maximum number of elements to transfer. The number actually
+ transfered will be less than or equal to this value.
+ - data
+ - Get sets data.data to it's internal array and data.offset to the
+ offset into the array. The caller is responsible for the actual data
+ transfer.
+ - from
+ - The array from which the data is taken. This array is supplied by the
+ caller
+ - fromOffset
+ - The offset in from
+
+
+The caller must be prepared to make multiple calls to retrieve or put an
+entire array. A caller should accept or put partial arrays. For example the
+following reads an entire array:
+ void doubleArray getArray(PVDoubleArray *pv,doubleArray to,int lenArray)
+ {
+ int len = pv->getLength();
+ if(lenArray<len) len = lenArray;
+ DoubleArrayData data;
+ int offset = 0;
+ while(offset < len) {
+ int num = pv->get(offset,(len-offset),&data);
+ double *from = &data.data[data.offset];
+ double *to = &to[offset]
+ int numbytes = num*sizeof(double);
+ memcopy(from,to,numBytes);
+ offset += num;
+ }
+ }
+
+shareData results in the PVArray using the primitive array that is passed
+to this method. This is most useful for immutable arrays. In this case the
+caller must set the PVArray to be immutable. In the PVArray is not immutable
+then it is the applications responsibility to coordinate access to the array.
+Again this violates the principle that objects should not expose their
+internal data but is important for immutable arrays. For example pvData and
+the javaIOC define many enumerated structures where an enumerated structure
+has three fields: index, choice, and choices. Choices is a PVStringArray that
+holds the enumerated choices. Index is a PVInt that is the index of the
+currently selected choice and choice is a PVString which is the currently
+selected choice. For many enumerated structures the choices is immutable.
+Allowing the choices internal String[] to be shared between all the instances
+of an enumerated structure saves on storage. An example is alarmSeverity.
+Another reason for allowing shared data is so that an application which
+processes an array can be separated into multiple modules that directly
+access the internal data array of a PVArray. This can be required for
+minimizing CPU overhead. In this case it is the applications responsibility
+to coordinate access to the array.
+
+Complete set of PVArray Extensions
+class PVScalarArray : public PVArray {
+public:
+ virtual ~PVScalarArray();
+ ScalarArrayConstPtr getScalarArray() ;
+ virtual void setCapacity(int capacity) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVScalarrray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+private:
+};
+
+class BooleanArrayData {
+public:
+ BooleanArray data;
+ int offset;
+};
+
+class PVBooleanArray : public PVScalarArray {
+public:
+ virtual ~PVBooleanArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, BooleanArrayData *data) = 0;
+ virtual int put(int offset,int length, BooleanArray from, int fromOffset) = 0;
+ virtual void shareData(BooleanArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVBooleanArrayclass ByteArrayData {
+public:
+ ByteArray data;
+ int offset;
+};
+
+class PVByteArray : public PVScalarArray {
+public:
+ virtual ~PVByteArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, ByteArrayData *data) = 0;
+ virtual int put(int offset,int length, ByteArray from, int fromOffset) = 0;
+ virtual void shareData(ByteArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVByteArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class ShortArrayData {
+public:
+ ShortArray data;
+ int offset;
+};
+
+class PVShortArray : public PVScalarArray {
+public:
+ virtual ~PVShortArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, ShortArrayData *data) = 0;
+ virtual int put(int offset,int length, ShortArray from, int fromOffset) = 0;
+ virtual void shareData(ShortArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVShortArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+
+class IntArrayData {
+public:
+ IntArray data;
+ int offset;
+};
+
+class PVIntArray : public PVScalarArray {
+public:
+ virtual ~PVIntArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, IntArrayData *data) = 0;
+ virtual int put(int offset,int length, IntArray from, int fromOffset)= 0;
+ virtual void shareData(IntArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVIntArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class LongArrayData {
+public:
+ LongArray data;
+ int offset;
+};
+
+class PVLongArray : public PVScalarArray {
+public:
+ virtual ~PVLongArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, LongArrayData *data) = 0;
+ virtual int put(int offset,int length, LongArray from, int fromOffset)= 0;
+ virtual void shareData(LongArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVLongArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class FloatArrayData {
+public:
+ FloatArray data;
+ int offset;
+};
+
+class PVFloatArray : public PVScalarArray {
+public:
+ virtual ~PVFloatArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, FloatArrayData *data) = 0;
+ virtual int put(int offset,int length, FloatArray from, int fromOffset)= 0;
+ virtual void shareData(FloatArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+
+class DoubleArrayData {
+public:
+ DoubleArrayData(){}
+ ~DoubleArrayData(){};
+ DoubleArray data;
+ int offset;
+};
+
+class PVDoubleArray : public PVScalarArray {
+public:
+ virtual ~PVDoubleArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, DoubleArrayData *data) = 0;
+ virtual int put(int offset,int length, DoubleArray from, int fromOffset) = 0;
+ virtual void shareData(DoubleArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class StringArrayData {
+public:
+ StringArray data;
+ int offset;
+};
+
+class PVStringArray : public PVScalarArray {
+public:
+ virtual ~PVStringArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, StringArrayData *data) = 0;
+ virtual int put(int offset,int length, StringArray from, int fromOffset)= 0;
+ virtual void shareData(StringArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVStringArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+Notes about PVStructureArray: A client can only access the data in the
+elements of the array via the get and put methods, i.e. it is not possible to
+access subfields indirectly. PVStructureArray.getNumberFields() returns 1,
+i.e. the field looks like a leaf field.
+
+PVStructure
+
+The interface for a structure is:
+class PVStructure : public PVField,public BitSetSerializable {
+public:
+ virtual ~PVStructure();
+ StructureConstPtr getStructure();
+ PVFieldPtrArray getPVFields();
+ PVField *getSubField(String fieldName);
+ PVField *getSubField(int fieldOffset);
+ void appendPVField(PVField *pvField);
+ void appendPVFields(int numberFields,PVFieldPtrArray pvFields);
+ void removePVField(String fieldName);
+ PVBoolean *getBooleanField(String fieldName);
+ PVByte *getByteField(String fieldName);
+ PVShort *getShortField(String fieldName);
+ PVInt *getIntField(String fieldName);
+ PVLong *getLongField(String fieldName);
+ PVFloat *getFloatField(String fieldName);
+ PVDouble *getDoubleField(String fieldName);
+ PVString *getStringField(String fieldName);
+ PVStructure *getStructureField(String fieldName);
+ PVScalarArray *getScalarArrayField(
+ String fieldName,ScalarType elementType);
+ PVStructureArray *getStructureArrayField(String fieldName);
+ String getExtendsStructureName();
+ bool putExtendsStructureName(
+ String extendsStructureName);
+ virtual bool operator==(PVField &pv) ;
+ virtual bool operator!=(PVField &pv) ;
+ virtual void serialize(
+ ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+ virtual void deserialize(
+ ByteBuffer *pbuffer,DeserializableControl *pflusher);
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) ;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher,BitSet *pbitSet) ;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl*pflusher,BitSet *pbitSet);
+protected:
+ PVStructure(PVStructure *parent,StructureConstPtr structure);
+private:
+ class PVStructurePvt * pImpl;
+};
+
+where
+
+ - getStructure
+ - Get the introspection interface for the structure.
+ - getPVFields
+ - Returns the array of subfields. The set of subfields must all have
+ different field names.
+ - getSubField(String fieldName)
+ - Get a subField of a field. For a PVStructure a non-null result is
+ returned if fieldName is a field of the PVStructure. The fieldName can
+ be of the form name.name...
+ - getSubField(int fieldOffset)
+ - Get the field located a fieldOffset, where fieldOffset is relative to
+ the top level structure. This returns null if the specified field is
+ not located within this PVStructure.
+ - appendPVField
+ - Append pvField to the end of this PVStructure. This should NOT be
+ called if any code is attached to any of the fields in the top level
+ structure.
+ - appendPVFields
+ - Append an array of pvFields to the end of this structure. Note that
+ if the original number of fields is 0 than pvFields replaces the
+ original. Thus the caller must NOT reuse pvFields after calling this
+ method. This should NOT be called if any code is attached to any of the
+ fields in the top level structure
+ - removePVField
+ - Remove the specified field from this structure. This should NOT be
+ called if any code is attached to any of the fields in the top level
+ structure.
+ - getBooleanField
+ - Look for fieldName. If found and it has the correct type return the
+ interface. This and the following methods are convenience methods that
+ allow a user to get the interface to a subfield without requiring
+ introspection. fieldName can be of the form name.name...
+ - getByteField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getShortField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getIntField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getLongField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getFloatField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getDoubleField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getStringField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getScalarArrayField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getStructureArrayField
+ - Look for fieldName. If found and it has the correct type return the
+ interface.
+ - getExtendsStructureName
+ - Get the name of structure that this structure extends.
+ - putExtendsStructureName
+ - Specify the structure that this structure extends.
+
+
+PVStructureArray
+
+The interface for an array of structures is:
+class StructureArrayData {
+public:
+ PVStructurePtrArray data;
+ int offset;
+};
+
+class PVStructureArray : public PVArray {
+public:
+ virtual ~PVStructureArray();
+ virtual StructureArrayConstPtr getStructureArray() = 0;
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length,
+ StructureArrayData *data) = 0;
+ virtual int put(int offset,int length,
+ PVStructurePtrArray from, int fromOffset) = 0;
+ virtual void shareData( PVStructurePtrArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0 ;
+ virtual void deserialize(ByteBuffer *buffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVStructureArray(PVStructure *parent,
+ StructureArrayConstPtr structureArray);
+private:
+};
+
+where
+
+PVDataCreate
+
+PVDataCreate is an interface that provides methods that create PVField
+interfaces. A factory is provided that creates PVDataCreate.
+class PVDataCreate {
+public:
+ PVField *createPVField(PVStructure *parent,
+ FieldConstPtr field);
+ PVField *createPVField(PVStructure *parent,
+ String fieldName,PVField * fieldToClone);
+ PVScalar *createPVScalar(PVStructure *parent,ScalarConstPtr scalar);
+ PVScalar *createPVScalar(PVStructure *parent,
+ String fieldName,ScalarType scalarType);
+ PVScalar *createPVScalar(PVStructure *parent,
+ String fieldName,PVScalar * scalarToClone);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ ScalarArrayConstPtr scalarArray);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ String fieldName,PVScalarArray * scalarArrayToClone);
+ PVStructureArray *createPVStructureArray(PVStructure *parent,
+ StructureArrayConstPtr structureArray);
+ PVStructure *createPVStructure(PVStructure *parent,
+ StructureConstPtr structure);
+ PVStructure *createPVStructure(PVStructure *parent,
+ String fieldName,int numberFields,FieldConstPtrArray fields);
+ PVStructure *createPVStructure(PVStructure *parent,
+ String fieldName,PVStructure *structToClone);
+protected:
+ PVDataCreate();
+ friend PVDataCreate * getPVDataCreate();
+};
+
+extern PVDataCreate * getPVDataCreate();
+
+where
+
+ - createPVField
+ - The PVField is created reusing the Field interface. Two methods are
+ provided. Each calls the corresponding createPVScalar, createPVArray,
+ or createPVStructure depending in the type os the last argument.
+ - createPVScalar
+ - Creates an instance of a PVScalar. Three versions are supplied. The
+ first is passed an introspection interface. The second provides the
+ field name and the scalarType. The last provides a field name and a
+ PVScalar to clone. The newly created PVScalar will have the same
+ auxInfos as the original.
+ - createPVScalarArray
+ - Create an instance of a PVArray. Three versions are supplied. The
+ first is passed an introspection interface. The second provides the
+ field name and the elementType. The last provides a field name and a
+ PVArray to clone. The newly created PVArray will have the same auxInfos
+ as the original.
+ - createPVStructureArray
+ - Create a PVStructureArray. It must be passed a structureToClone. This
+ will become the Structure interface for ALL elements of the
+ PVStructureArray. It MUST be used to create any new array elements.
+ - createPVStructure
+ - Create an instance of a PVStructure. Four methods are provided. The
+ first method uses a previously created structure introspection
+ interface. The second uses a Field array to initialize the sub-fields.
+ The third initializes the subfields by cloning the fields contained in
+ structToClone. The newly created sub-fields will have the same values
+ and auxInfos as the original. If structToClone is null then the new
+ structure is initialized to have 0 sub-fields.
+ - flattenPVStructure
+ - Create an array of PVFields for the fields in the PVStructure. The
+ order is according to fieldOffset.
+
+
+Standard Data Fields
+
+A class StandardPVField has methods for creating standard data fields.
+Like class StandardField it has two forms of the methods which create a
+field, one without properties and one with properties. Again the properties
+is some combination of alarm, timeStamp, control, display, and valueAlarm.
+And just like StandardField there are methods to create thye standard
+properties. The meythods are:
+class StandardPVField : private NoDefaultMethods {
+public:
+ StandardPVField();
+ ~StandardPVField();
+ PVScalar * scalar(PVStructure *parent,String fieldName,ScalarType type);
+ PVStructure * scalar(PVStructure *parent,
+ String fieldName,ScalarType type,String properties);
+ PVScalarArray * scalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType);
+ PVStructure * scalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType, String properties);
+ PVStructureArray * structureArray(PVStructure *parent,
+ String fieldName,StructureConstPtr structure);
+ PVStructure* structureArray(PVStructure *parent,
+ String fieldName,StructureConstPtr structure,String properties);
+ PVStructure * enumerated(PVStructure *parent,
+ String fieldName,StringArray choices);
+ PVStructure * enumerated(PVStructure *parent,
+ String fieldName,StringArray choices, String properties);
+ PVScalar * scalarValue(PVStructure *parent,ScalarType type);
+ PVStructure * scalarValue(PVStructure *parent,
+ ScalarType type,String properties);
+ PVScalarArray * scalarArrayValue(PVStructure *parent,ScalarType elementType);
+ PVStructure * scalarArrayValue(PVStructure *parent,
+ ScalarType elementType, String properties);
+ PVStructureArray * structureArrayValue(PVStructure *parent,
+ StructureConstPtr structure);
+ PVStructure * structureArrayValue(PVStructure *parent,
+ StructureConstPtr structure,String properties);
+ PVStructure * enumeratedValue(PVStructure *parent,StringArray choices);
+ PVStructure * enumeratedValue(PVStructure *parent,
+ StringArray choices, String properties);
+ PVStructure * alarm(PVStructure *parent);
+ PVStructure * timeStamp(PVStructure *parent);
+ PVStructure * display(PVStructure *parent);
+ PVStructure * control(PVStructure *parent);
+ PVStructure * booleanAlarm(PVStructure *parent);
+ PVStructure * byteAlarm(PVStructure *parent);
+ PVStructure * shortAlarm(PVStructure *parent);
+ PVStructure * intAlarm(PVStructure *parent);
+ PVStructure * longAlarm(PVStructure *parent);
+ PVStructure * floatAlarm(PVStructure *parent);
+ PVStructure * doubleAlarm(PVStructure *parent);
+ PVStructure * enumeratedAlarm(PVStructure *parent);
+ PVStructure * powerSupply(PVStructure *parent);
+};
+
+Convert
+
+NOTE about copying immutable array fields. If an entire immutable array
+field is copied to another array that has the same elementType, both offsets
+are 0, and the length is the length of the source array, then the shareData
+method of the target array is called and the target array is set immutable.
+Thus the source and target share the same primitive array.
+
+This section describes the supported conversions between data types.
+
+ - All supported types can be converted to a string. If you ask for a 100
+ megabyte array to be converted to a string expect a lot of output.
+ - Conversion from a string to a scalar type.
+ - Conversion from an array of strings to an array of scalar types.
+ - Copy between the following types of scalar PVs
+
+ - Numeric type to another numeric type
+ - Both have the same type.
+ - Either is a string
+
+
+ - Copy between PVArrays that satisfy one of the following.
+
+ - Numeric to numeric
+ - Both have the same type.
+ - Either is a string.
+
+
+ - Conversions between numeric scalar types.
+ - Conversions between arrays of numeric type.
+ - Conversion between compatible structures.
+ - A utility method the returns the full field name of a field
+
+class Convert : NoDefaultMethods {
+public:
+ Convert();
+ ~Convert();
+ void getFullName(StringBuilder buf,PVField *pvField);
+ bool equals(PVField *a,PVField *b);
+ void getString(StringBuilder buf,PVField * pvField,int indentLevel);
+ void getString(StringBuilder buf,PVField *pvField);
+ void fromString(PVScalar *pv, String from);
+ int fromString(PVScalarArray *pv, String from);
+ int fromStringArray(PVScalarArray *pv, int offset, int length,
+ StringArray from, int fromOffset);
+ int toStringArray(PVScalarArray *pv, int offset, int length,
+ StringArray to, int toOffset);
+ bool isCopyCompatible(FieldConstPtr from, FieldConstPtr to);
+ void copy(PVField *from,PVField *to);
+ bool isCopyScalarCompatible(
+ ScalarConstPtr from, ScalarConstPtr to);
+ void copyScalar(PVScalar *from, PVScalar *to);
+ bool isCopyScalarArrayCompatible(ScalarArrayConstPtr from,
+ ScalarArrayConstPtr to);
+ int copyScalarArray(PVScalarArray *from, int offset,
+ PVScalarArray *to, int toOffset, int length);
+ bool isCopyStructureCompatible(
+ StructureConstPtr from, StructureConstPtr to);
+ void copyStructure(PVStructure *from, PVStructure *to);
+ bool isCopyStructureArrayCompatible(
+ StructureArrayConstPtr from, StructureArrayConstPtr to);
+ void copyStructureArray(
+ PVStructureArray *from, PVStructureArray *to);
+ int8 toByte(PVScalar *pv);
+ int16 toShort(PVScalar *pv);
+ int32 toInt(PVScalar *pv);
+ int64 toLong(PVScalar *pv);
+ float toFloat(PVScalar *pv);
+ double toDouble(PVScalar *pv);
+ void fromByte(PVScalar *pv,int8 from);
+ void fromShort(PVScalar *pv,int16 from);
+ void fromInt(PVScalar *pv, int32 from);
+ void fromLong(PVScalar *pv, int64 from);
+ void fromFloat(PVScalar* pv, float from);
+ void fromDouble(PVScalar *pv, double from);
+ int toByteArray(PVScalarArray *pv, int offset, int length,
+ ByteArray to, int toOffset);
+ int toShortArray(PVScalarArray *pv, int offset, int length,
+ ShortArray to, int toOffset);
+ int toIntArray(PVScalarArray *pv, int offset, int length,
+ IntArray to, int toOffset);
+ int toLongArray(PVScalarArray *pv, int offset, int length,
+ LongArray to, int toOffset);
+ int toFloatArray(PVScalarArray *pv, int offset, int length,
+ FloatArray to, int toOffset);
+ int toDoubleArray(PVScalarArray *pv, int offset, int length,
+ DoubleArray to, int toOffset);
+ int fromByteArray(PVScalarArray *pv, int offset, int length,
+ ByteArray from, int fromOffset);
+ int fromShortArray(PVScalarArray *pv, int offset, int length,
+ ShortArray from, int fromOffset);
+ int fromIntArray(PVScalarArray *pv, int offset, int length,
+ IntArray from, int fromOffset);
+ int fromLongArray(PVScalarArray *pv, int offset, int length,
+ LongArray from, int fromOffset);
+ int fromFloatArray(PVScalarArray *pv, int offset, int length,
+ FloatArray from, int fromOffset);
+ int fromDoubleArray(PVScalarArray *pv, int offset, int length,
+ DoubleArray from, int fromOffset);
+ void newLine(StringBuilder buf, int indentLevel);
+};
+
+extern Convert * getConvert();
+
+The array methods all return the number of elements copied or converted.
+This can be less than len if the
+PVField array contains less than len elements.
+
+newLine is a convenience method
+for code that implements toString
+It generates a newline and inserts blanks at the beginning of the newline.
+
+
+Examples
+
+
+Accessing PVData
+
+Assume that code wants to print two fields from a PVStructure:
+
+ - value
+ - Must be a PVDouble.
+ - timeStamp
+ - Just look for field with this name.
+
+
+The following code uses introspection to get the desired information.
+void getValueAndTimeStamp(PVStructure pvStructure,Stringbuffer buf) {
+ PVField *valuePV = pvStructure->getSubField(String("value"));
+ if(valuePV==0) {
+ buf += "value field not found";
+ return;
+ }
+ buf += "value ";
+ valuePV->toString(buf);
+ PVField *timeStampPV = pvStructure->getSubField(String("timeStamp"));
+ if(timeStampPV==0) {
+ buf += "timeStamp field not found";
+ return;
+ }
+ buf += " timeStamp ";
+ timeStampPV->toString(buf);
+}
+
+Creating PVData
+
+Example of creating a scalar field.
+ PVDataCreate *pvDataCreate = getPVDataCreate();
+ PVDouble pvValue = pvDataCreate.createPVScalar(
+ 0,
+ String("value"),
+ pvDouble);
+
+Create an alarm structure the hard way
+ FieldCreate *fieldCreate = getFieldCreate();
+ PVDataCreate *pvDataCreate = getPVDataCreate();
+ FieldConstPtrArray fields = new FieldConstPtr[2];
+ fields[0] = fieldCreate->createScalar(String("severity"),pvInt);
+ fields[1] = fieldCreate->createScalar(String("message"),pvString);
+ StructureConstPtralarmField = fieldCreate->createStructure(String("alarm"),2,fields);
+
+Create an alarm structure the easy way.
+ StandardPVField *standardPVField = getStandardPVField();
+ PVStructure *pvAlarm = standardPVField->alarm(0);
+
+Create a PVStructure with field name example that has a double value field
+and a timeStamp and alarm. Do it the easy way.
+ StandardPVField *standardPVField = getStandardPVField();
+ PVStructure *pvStructure = standardPVField->scalar(
+ 0, //parent is null
+ String("example"),
+ String("timeStamp,alarm"))
+
+
+pvMisc
+
+
+BitSetUtil
+
+The following is also provided:
+NOT DONE
+
+This provides functions that operate of a BitSet for a PVStructure. It
+currently has only one method:
+
+ - compress
+ - Compress the bits in a BitSet related to a structure.
+ For each structure:
+
+ - If the bit for the structure is set then the bit for all
+ subfields of the structure are cleared.
+ - If the bit for the structure is not set but all immediate
+ subfields have their bit set then the bit for the structure is set
+ and the bits for all subfields are cleared.
+
+ Note that this is a recursive algorithm. That is if every immediate
+ subfield has it's offset bit set then the bits for ALL fields that
+ reside in the structure will be cleared.
+ - Channel Access can call this before sending data. It can then pass
+ entire structures if the structure offset bit is set.
+
+
+MultiChoice
+
+MultiChoice defines an array of strings and a bit set that selects an
+arbitrary set of the choices.
+NOT DONE
+
+where
+
+ - getBitMask
+ - Returns the bitMask.
+ - getChoices
+ - Returns the complete set of choices..
+ - getSelectedChoices
+ - Returns the interface for getting the selected choices..
+ - setBit
+ - Select the choice for specified bit..
+ - clear
+ - Clear the bitMask, i.e. no choices are selected..
+ - registerChoice
+ - Register a new choice. If thed choice already exists then it''s index
+ is returned. If not it is appended to the choices.
+
+
+
+Property
+
+
+Definition of Property
+
+NOTE: The use of property is discouraged. But the Interfaces for standard
+properties are encouraged.
+
+Only fields named "value" have properties. A record can have multiple
+value fields, which can appear in the top level structure of a record or in a
+substructure. All other fields in the structure containing a value field are
+considered properties of the value field. The fieldname is also the property
+name. The value field can have any type, i.e. scalar, scalarArray, or
+structure. Typical property fields are timeStamp, alarm, display, control,
+and history.
+
+The timeStamp is a special case. If it appears anywhere in the structure
+hieraracy above a value field it is a property of the value field.
+
+For example the following record has a single value field. The value field
+has propertys alarm, timeStamp, and display.
+<record name = "counterOutput" >
+ <structure name = "alarm" extends = "alarm" />
+ <structure name = "timeStamp" extends = "timeStamp" />
+ <scalar name = "value" scalarType = "double" />
+ <structure name = "display" extends = "display" >
+ <scalar name = "description">Sample Description</scalar>
+ <scalar name = "format">%f</scalar>
+ <scalar name = "units">volts</scalar>
+ <structure name = "limit">
+ <scalar name ="low">0.0</scalar>
+ <scalar name ="high">10.0</scalar>
+ </structure>
+ </structure>
+</record>
+
+The following example has three value fields each with properties alarm
+and timeStamp. Voltage, Current, and Power each have a different alarms but
+all share the timeStamp.
+<record name = "psSimple">
+ <structure name = "alarm" extends = "alarm" />
+ <structure name = "timeStamp" extends = "timeStamp" />
+ <structure name = "voltage">
+ <scalar name = "value" scalarType = "double" />
+ <structure name = "alarm" extends = "alarm" />
+ </structure>
+ <structure name = "current">
+ <scalar name = "value" scalarType = "double" />
+ <structure name = "alarm" extends = "alarm" />
+ </structure>
+ <structure name = "power">
+ <scalar name = "value" scalarType = "double" />
+ <structure name = "alarm" extends = "alarm" />
+ </structure>
+</record>
+
+Standard Properties
+
+The following field names have special meaning, i.e. support properties
+for general purpose clients.
+
+ - value
+ - This is normally defined since most general purpose clients access
+ this field. All other fields in the structure support or describe the
+ value field. The type can any supported type but is usually one of the
+ following:
+
+ - scalar
+ - One of boolean, byte, short, int, long, float, double, or
+ string
+ - scalarArray
+ - An array with the elementType being a scalar type
+ - enumerated structure
+ - A structure that includes fields named index, choice, and
+ choices. index is an int that selects a choice. choice is the
+ currently selected choice. choices is an array of strings that
+ defines the complete set of choices.
+ - other
+ - Other structure or array types can also be defined if clients
+ and support code agree on the meaning. Some examples are: 1) A
+ structure defining a 2D matrix, 2) A structure defining an image,
+ 3) A structure that simulates a remote method, ...
+
+
+ - timeStamp
+ - The timeStamp. The type MUST be a timeStamp structure. Also if the
+ PVData structure does not have a timeStamp then a search up the parent
+ tree is made to find a timeStamp.
+ - alarm
+ - The alarm. The type MUST be an alarm structure.
+ - display
+ - A display structure as described below. It provides display
+ characteristics for the value field.
+ - control
+ - A control structure as described below. It provides control
+ characteristics for the value field.
+ - history
+ - Provides a history buffer for the value field. Note that currently
+ PVData does not define history suppoprt.
+ - other
+ - Other standard properties can be defined.
+
+
+In addition a structure can have additional fields that support the value
+field but are not recognized by most general purpose client tools. Typical
+examples are:
+
+ - input
+ - A field with support that changes the value field. This can be
+ anything. It can be a channel access link. It can obtain a value from
+ hardware. Etc.
+ - valueAlarm
+ - A field with support that looks for alarm conditions based on the
+ value.
+ - output
+ - A field with support that reads the current value and sends it
+ somewhere else. This can be anything. It can be a channel access link.
+ It can write a value to hardware. Etc.
+
+
+The model allows for device records. A device record has fields that are
+structures that support the PVData data model. For example a powerSupport
+record can have fields power, voltage, current that each support the PVData
+data model.
+
+PVProperty
+
+Interface and factory for finding a field within a structure.
+NOT DONE
+
+ - findProperty
+ Find a field that is a subfield or property of this PVField. The
+ fieldName is of the form name.name... The pvField must be named value or
+ it does not have properties.
+ - findPropertyViaParent
+ Find a property by searching up the parent tree. The property name is
+ expected to match the name of a field. The return value is the interface
+ to the first field found that is not a null structure or null if not
+ found.
+ - getPropertyNames
+ Get a String array that holds the names of the properties for this field.
+
+ - getPVProperty
+ Get the single instance of PVProperty.
+
+
+Enumeration
+
+Enumerated is a convenience interface for a structure that happens to be
+an enumerated structure, which is a structure that has fields index and
+choices. Index is an integer and choices is an array of strings. Both index
+selects one of the choices.
+class Enumerated ;
+public:
+ //default constructors and destructor are OK
+ //This class should not be extended
+
+ //returns (false,true) if pvField(isNot, is valid enumerated structure
+ bool attach(PVField *pvField);
+ ~Enumerated();
+ // each of the following throws logic_error is not attached to PVField
+ void putIndex(int32 index);
+ int32 getIndex();
+ String getChoice();
+ bool choicesMutable();
+ StringArray getChoices();
+ int32 getNumberChoices();
+ // also throws logic_error of immutable
+ void putChoices(StringArray choices,int32 numberChoices);
+private:
+ PVInt *pvIndex;
+ PVStringArray *pvChoices;
+};
+
+where
+
+ - getIndex
+ - Returns the interface for field index.
+ - getChoice
+ - Returns the choice for the current index.
+ - getChoices
+ - Returns the interface for field choices.
+ - getPV
+ - Returns the interface for the PVStructure for the enumerated
+ structure.
+ - replacePVField
+ - Replace the PVField implementation. The new implementation implements
+ interface Enumerated and also replaces the implementations of fields
+ index, choice, and choices. The new implementation updates index when
+ choice is changed and choice when index is changed. If choices is
+ changed the index is set to 0.
+ - getEnumerated
+ - If the field is an enumerated structure and replacePVField was called
+ for the field then interface Enumerated is returned.
+
+
+Standard Properties
+
+This section has structure definitions that support standard properties.
+These definitions are defined in project javaIOC.
+
+TimeStamp
+<structure name = "timeStamp">
+ <scalar name = "secondsPastEpoch" scalarType = "long" />
+ <scalar name = "nanoSeconds" scalarType = "int" />
+</structure>
+
+Alarm
+<structure name = "alarmSeverity" extends = "enumerated" >
+ <array name = "choices" immutable = "true" >none,minor,major,invalid</array>
+</structure>
+
+<structure name = "alarm">
+ <structure name = "severity" extends = "alarmSeverity" />
+ <scalar name = "message" scalarType = "string" />
+</structure>
+
+Limits
+<structure name = "byteLimit">
+ <scalar name = "low" scalarType = "byte" />
+ <scalar name = "high" scalarType = "byte" />
+</structure>
+
+<structure name = "shortLimit">
+ <scalar name = "low" scalarType = "short" />
+ <scalar name = "high" scalarType = "short" />
+</structure>
+
+<structure name = "intLimit">
+ <scalar name = "low" scalarType = "int" />
+ <scalar name = "high" scalarType = "int" />
+</structure>
+
+<structure name = "longLimit">
+ <scalar name = "low" scalarType = "long" />
+ <scalar name = "high" scalarType = "long" />
+</structure>
+
+<structure name = "floatLimit">
+ <scalar name = "low" scalarType = "float" />
+ <scalar name = "high" scalarType = "float" />
+</structure>
+
+<structure name = "doubleLimit">
+ <scalar name = "low" scalarType = "double" />
+ <scalar name = "high" scalarType = "double" />
+</structure>
+
+Display
+<structure name = "display">
+ <scalar name = "description" scalarType = "string" />
+ <scalar name = "format" scalarType = "string" />
+ <scalar name = "units" scalarType = "string" />
+ <structure name = "limit" extends = "doubleLimit" />
+</structure>
+
+Control
+<structure name = "control">
+ <structure name = "limit" extends = "doubleLimit" />
+ <scalar name = "minStep" scalarType = "double" />
+</structure>
+
+Interfaces for Standard Properties
+
+PVTimeStamp
+
+The following priovides convient access to a timeStamp structure.
+class PVTimeStamp {
+public:
+ //default constructors and destructor are OK
+ //This class should not be extended
+
+ //returns (false,true) if pvField(isNot, is valid timeStamp structure
+ bool attach(PVField *pvField);
+ // throws logic_error is not attached to PVField
+ TimeStamp &get();
+ // throws logic_error is not attached to PVField
+ void put (TimeStamp &timeStamp);
+private:
+ PVLong* pvSecs;
+ PVInt* pvNano;
+};
+
+Alarm
+
+The following provides convient access to the fields of an alarm
+structure.
+NOT DONE
+
+Limits
+
+Display
+
+Control
+
+
+PVData Abstract and Base Classes
+
+
+Overview
+
+This package provides classes that implement everything defined in package
+org.epics.pvData.pv
+
+Factory
+
+FieldCreateFactory automatically creates a single instance of FieldCreate
+and provides a method to get the interface.
+
+PVDataCreateFactory automatically creates a single instance of
+PVDataCreate and provides a method to get the interface.
+
+PVAuxInfoImpl implements auxInfo.
+
+ConvertFactory automatically creates a single instance of Convert and
+provides a method to get the interface.
+
+Abstract Classes for PVField
+
+AbstractPVField
+
+This is an abstract base class for implementing PVField interfaces. It
+MUST be the base class for any class that extends PVField.
+
+AbstractPVScalar
+
+This is an abstract base class for implementing scalar data fields. It
+MUST be the base class for any class that implements a scalar data field.
+
+AbstractPVArray
+
+This is an abstract base class for implementing array data fields. It MUST
+be the base class for any class implements array data fields.
+
+AbstractPVScalarArray
+
+This is an abstract base class for implementing scalar array data fields.
+It MUST be the base class for any class implements scalar array data fields.
+
+
+BasePVStructure
+
+BasePVStructure is a base class for any code that implements PVStructure.
+Any code that implements PVStructure MUST extend this class.
+
+Base Classes For PVScalar
+
+For each scalar type there is a base class that implements it. The
+complete list is:
+
+ - BasePVBoolean
+ - BasePVByte
+ - BasePVShort
+ - BasePVInt
+ - BasePVLong
+ - BasePVFloat
+ - BasePVDouble
+ - BasePVString
+
+
+Base Classes for PVArray
+
+For each scalar array type there is a base class that implements it. The
+complete list is:
+
+ - BasePVBooleanArray
+ - BasePVByteArray
+ - BasePVShortArray
+ - BasePVIntArray
+ - BasePVLongArray
+ - BasePVFloatArray
+ - BasePVDoubleArray
+ - BasePVStringArray
+ - BasePVStructureArray
+
+
+
+License Agreement
+
+Copyright (c) 2008 Martin R. Kraimer
+Copyright (c) 2007 Control System Laboratory,
+ (COSYLAB) Ljubljana Slovenia
+Copyright (c) 2010 Brookhaven National Laboratory
+
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+________________________________________________________________________
+
+This software is in part copyrighted by Brookhaven National Laboratory(BNL)
+
+In no event shall BNL be liable to any party for direct, indirect,
+special, incidental, or consequential damages arising out of the use of
+this software, its documentation, or any derivatives thereof, even if
+BNL has been advised of the possibility of such damage.
+
+BNL specifically disclaims any warranties, including, but not limited
+to, the implied warranties of merchantability, fitness for a particular
+purpose, and non-infringement. This software is provided on an "as is"
+basis, and BNL has no obligation to provide maintenance, support,
+updates, enhancements, or modifications.
+
+________________________________________________________________________
+
+This software is in part copyrighted by the BERLINER SPEICHERRING
+GESELLSCHAFT FUER SYNCHROTRONSTRAHLUNG M.B.H. (BESSY), BERLIN, GERMANY.
+
+In no event shall BESSY be liable to any party for direct, indirect,
+special, incidental, or consequential damages arising out of the use of
+this software, its documentation, or any derivatives thereof, even if
+BESSY has been advised of the possibility of such damage.
+
+BESSY specifically disclaims any warranties, including, but not limited
+to, the implied warranties of merchantability, fitness for a particular
+purpose, and non-infringement. This software is provided on an "as is"
+basis, and BESSY has no obligation to provide maintenance, support,
+updates, enhancements, or modifications.
+
+________________________________________________________________________
+
+This software is in part copyrighted by the Deutsches Elektronen-Synchroton,
+ Member of the Helmholtz Association, (DESY), HAMBURG, GERMANY.
+
+In no event shall DESY be liable to any party for direct, indirect,
+special, incidental, or consequential damages arising out of the use of
+this software, its documentation, or any derivatives thereof, even if
+DESY has been advised of the possibility of such damage.
+
+DESY specifically disclaims any warranties, including, but not limited
+to, the implied warranties of merchantability, fitness for a particular
+purpose, and non-infringement. This software is provided on an "as is"
+basis, and DESY has no obligation to provide maintenance, support,
+updates, enhancements, or modifications.
+________________________________________________________________________
+
+
diff --git a/pvDataApp/misc/Makefile b/pvDataApp/misc/Makefile
index 5f13ed9..1d44f01 100644
--- a/pvDataApp/misc/Makefile
+++ b/pvDataApp/misc/Makefile
@@ -23,6 +23,7 @@ INC += timer.h
LIBSRCS += byteBuffer.cpp
LIBSRCS += bitSet.cpp
+LIBSRCS += requester.cpp
LIBSRCS += serializeHelper.cpp
LIBSRCS += showConstructDestruct.cpp
LIBSRCS += linkedListVoid.cpp
diff --git a/pvDataApp/misc/bitSet.h b/pvDataApp/misc/bitSet.h
index 8e957be..f477e1c 100644
--- a/pvDataApp/misc/bitSet.h
+++ b/pvDataApp/misc/bitSet.h
@@ -12,10 +12,6 @@
//#include "serialize.h"
namespace epics { namespace pvData {
- // TODO !!!
- typedef unsigned long long uint64;
- typedef std::string * StringBuilder;
-
/**
* This class implements a vector of bits that grows as needed. Each
* component of the bit set has a {@code bool} value. The
diff --git a/pvDataApp/misc/event.cpp b/pvDataApp/misc/event.cpp
index 31b19e7..ea0b4f1 100644
--- a/pvDataApp/misc/event.cpp
+++ b/pvDataApp/misc/event.cpp
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
@@ -56,13 +57,17 @@ static void init()
Event::~Event() {
epicsEventDestroy(id);
+ id = 0;
+ Lock xx(globalMutex);
totalDestruct++;
}
-Event::Event(EventInitialState initial)
-: id(epicsEventCreate((initial==eventEmpty)?epicsEventEmpty : epicsEventFull))
+
+Event::Event(bool full)
+: id(epicsEventCreate(full?epicsEventFull : epicsEventEmpty))
{
init();
+ Lock xx(globalMutex);
totalConstruct++;
}
@@ -74,23 +79,27 @@ ConstructDestructCallback *Event::getConstructDestructCallback()
void Event::signal()
{
+ if(id==0) throw std::logic_error(String("event was deleted"));
epicsEventSignal(id);
}
bool Event::wait ()
{
+ if(id==0) throw std::logic_error(String("event was deleted"));
epicsEventWaitStatus status = epicsEventWait(id);
return status==epicsEventWaitOK ? true : false;
}
bool Event::wait ( double timeOut )
{
+ if(id==0) throw std::logic_error(String("event was deleted"));
epicsEventWaitStatus status = epicsEventWaitWithTimeout(id,timeOut);
return status==epicsEventWaitOK ? true : false;
}
bool Event::tryWait ()
{
+ if(id==0) throw std::logic_error(String("event was deleted"));
epicsEventWaitStatus status = epicsEventTryWait(id);
return status==epicsEventWaitOK ? true : false;
}
diff --git a/pvDataApp/misc/event.h b/pvDataApp/misc/event.h
index 25e0edf..00dcdb0 100644
--- a/pvDataApp/misc/event.h
+++ b/pvDataApp/misc/event.h
@@ -16,22 +16,10 @@
namespace epics { namespace pvData {
-enum EventWaitStatus {
- eventWaitOK,
- eventWaitTimeout,
- eventWaitError
-};
-
-enum EventInitialState {
- eventEmpty,
- eventFull
-};
-
-
class Event : private NoDefaultMethods {
public:
+ explicit Event(bool = false);
~Event();
- Event(EventInitialState initial);
static ConstructDestructCallback *getConstructDestructCallback();
void signal();
bool wait (); /* blocks until full */
diff --git a/pvDataApp/misc/executor.cpp b/pvDataApp/misc/executor.cpp
index dcce275..bb96898 100644
--- a/pvDataApp/misc/executor.cpp
+++ b/pvDataApp/misc/executor.cpp
@@ -81,14 +81,13 @@ ConstructDestructCallback *Executor::getConstructDestructCallback()
return pConstructDestructCallback;
}
-class ExecutorPvt : public RunnableReady {
+class ExecutorPvt : public Runnable{
public:
ExecutorPvt(String threadName,ThreadPriority priority);
~ExecutorPvt();
ExecutorNode * createNode(Command *command);
void execute(ExecutorNode *node);
- void destroy();
- virtual void run(ThreadReady *threadReady);
+ virtual void run();
private:
ExecutorList *executorList;
ExecutorList *runList;
@@ -102,37 +101,39 @@ private:
ExecutorPvt::ExecutorPvt(String threadName,ThreadPriority priority)
: executorList(new ExecutorList()),
runList(new ExecutorList()),
- moreWork(new Event(eventEmpty)),
- stopped(new Event(eventEmpty)),
+ moreWork(new Event(false)),
+ stopped(new Event(false)),
mutex(Mutex()),
alive(true),
thread(new Thread(threadName,priority,this))
-{
- thread->start();
-}
+{}
ExecutorPvt::~ExecutorPvt()
{
+ {
+ Lock xx(&mutex);
+ alive = false;
+ }
+ moreWork->signal();
+ {
+ Lock xx(&mutex);
+ stopped->wait();
+ }
ExecutorListNode *node;
while((node=executorList->removeHead())!=0) {
delete node->getObject();
}
+ delete thread;
delete stopped;
delete moreWork;
delete runList;
delete executorList;
- delete thread;
}
-void ExecutorPvt::run(ThreadReady *threadReady)
+void ExecutorPvt::run()
{
- bool firstTime = true;
while(alive) {
ExecutorListNode * executorListNode = 0;
- if(firstTime) {
- firstTime = false;
- threadReady->ready();
- }
while(alive && runList->isEmpty()) {
moreWork->wait();
}
@@ -164,20 +165,6 @@ void ExecutorPvt::execute(ExecutorNode *node)
if(isEmpty) moreWork->signal();
}
-void ExecutorPvt::destroy()
-{
- {
- Lock xx(&mutex);
- alive = false;
- }
- moreWork->signal();
- {
- Lock xx(&mutex);
- stopped->wait();
- }
- delete this;
-}
-
Executor::Executor(String threadName,ThreadPriority priority)
: pImpl(new ExecutorPvt(threadName,priority))
{
@@ -187,23 +174,14 @@ Executor::Executor(String threadName,ThreadPriority priority)
}
Executor::~Executor() {
+ delete pImpl;
Lock xx(globalMutex);
totalDestruct++;
}
-Executor *Executor::create(String threadName,ThreadPriority priority)
-{
- return new Executor(threadName,priority);
-}
-
ExecutorNode * Executor::createNode(Command*command)
{return pImpl->createNode(command);}
void Executor::execute(ExecutorNode *node) {pImpl->execute(node);}
-void Executor::destroy() {
- pImpl->destroy();
- delete this;
-}
-
}}
diff --git a/pvDataApp/misc/executor.h b/pvDataApp/misc/executor.h
index b778cf7..1c70439 100644
--- a/pvDataApp/misc/executor.h
+++ b/pvDataApp/misc/executor.h
@@ -24,14 +24,12 @@ public:
class Executor : private NoDefaultMethods {
public:
- static ConstructDestructCallback *getConstructDestructCallback();
- static Executor *create(String threadName,ThreadPriority priority);
- ExecutorNode * createNode(Command *command);
- void execute(ExecutorNode *node);
- void destroy();
-private:
Executor(String threadName,ThreadPriority priority);
~Executor();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ ExecutorNode * createNode(Command *command);
+ void execute(ExecutorNode *node);
+private:
class ExecutorPvt *pImpl;
};
diff --git a/pvDataApp/misc/linkedList.h b/pvDataApp/misc/linkedList.h
index 757830d..abf41c5 100644
--- a/pvDataApp/misc/linkedList.h
+++ b/pvDataApp/misc/linkedList.h
@@ -17,8 +17,9 @@ class LinkedListNode : private LinkedListVoidNode {
public:
LinkedListNode(T *object) : LinkedListVoidNode(object){}
~LinkedListNode() {}
- T *getObject() { return (T *)LinkedListVoidNode::getObject();}
+ T *getObject() { return static_cast(LinkedListVoidNode::getObject());}
bool isOnList() {return LinkedListVoidNode::isOnList();}
+ friend class LinkedList;
};
template
@@ -29,49 +30,51 @@ public:
int getLength() {return LinkedListVoid::getLength();}
void addTail(LinkedListNode *listNode)
{
- LinkedListVoid::addTail((LinkedListVoidNode *)listNode);
+ LinkedListVoid::addTail(static_cast(listNode));
}
void addHead(LinkedListNode *listNode)
{
- LinkedListVoid::addHead((LinkedListVoidNode *)listNode);
+ LinkedListVoid::addHead(static_cast(listNode));
}
void insertAfter(LinkedListNode *listNode,
LinkedListNode *addNode)
{
LinkedListVoid::insertAfter(
- (LinkedListVoidNode *)listNode,(LinkedListVoidNode *)addNode);
+ static_cast(listNode),
+ static_cast(addNode));
}
void insertBefore(LinkedListNode *listNode,
LinkedListNode *addNode)
{
- LinkedListVoid::insertBefore((LinkedListVoidNode *)listNode,
- (LinkedListVoidNode *)addNode);
+ LinkedListVoid::insertBefore(
+ static_cast(listNode),
+ static_cast(addNode));
}
LinkedListNode *removeTail(){
- return (LinkedListNode*)LinkedListVoid::removeTail();
+ return static_cast *>(LinkedListVoid::removeTail());
}
LinkedListNode *removeHead(){
- return (LinkedListNode*)LinkedListVoid::removeHead();
+ return static_cast *>(LinkedListVoid::removeHead());
}
void remove(LinkedListNode *listNode){
- LinkedListVoid::remove((LinkedListVoidNode *)listNode);
+ LinkedListVoid::remove(static_cast(listNode));
}
void remove(T *object){
LinkedListVoid::remove(object);
}
LinkedListNode *getHead(){
- return (LinkedListNode*)LinkedListVoid::getHead();
+ return static_cast *>(LinkedListVoid::getHead());
}
LinkedListNode *getTail(){
- return (LinkedListNode*)LinkedListVoid::getTail();
+ return static_cast *>(LinkedListVoid::getTail());
}
LinkedListNode *getNext(LinkedListNode *listNode){
- return (LinkedListNode*)LinkedListVoid::getNext(
- (LinkedListVoidNode *)listNode);
+ return static_cast *>(LinkedListVoid::getNext(
+ static_cast(listNode)));
}
LinkedListNode *getPrev(LinkedListNode *listNode){
- return (LinkedListNode*)LinkedListVoid::getPrev(
- (LinkedListVoidNode *)listNode);
+ return static_cast *>(LinkedListVoid::getPrev(
+ static_cast(listNode)));
}
bool isEmpty() { return LinkedListVoid::isEmpty();}
bool contains(T *object) { return LinkedListVoid::contains(object);}
diff --git a/pvDataApp/misc/linkedListVoid.cpp b/pvDataApp/misc/linkedListVoid.cpp
index f6fd2c2..097b3a4 100644
--- a/pvDataApp/misc/linkedListVoid.cpp
+++ b/pvDataApp/misc/linkedListVoid.cpp
@@ -69,7 +69,7 @@ static void initPvt()
LinkedListVoidNode::LinkedListVoidNode(void *object)
-: object(object),before(0),after(0)
+: object(object),before(0),after(0),linkedListVoid(0)
{
initPvt();
Lock xx(globalMutex);
@@ -138,6 +138,7 @@ void LinkedListVoid::addTail(LinkedListVoidNode *node)
if(node->before!=0 || node->after!=0) {
throw std::logic_error(alreadyOnList);
}
+ node->linkedListVoid = this;
node->before = head->before;
node->after = head;
head->before->after = node;
@@ -150,6 +151,7 @@ void LinkedListVoid::addHead(LinkedListVoidNode *node)
if(node->before!=0 || node->after!=0) {
throw std::logic_error(alreadyOnList);
}
+ node->linkedListVoid = this;
node->after = head->after;
node->before = head;
head->after->before = node;
@@ -168,6 +170,10 @@ void LinkedListVoid::insertAfter(LinkedListVoidNode *node,
if(newNode->before!=0 || newNode->after!=0) {
throw std::logic_error(alreadyOnList);
}
+ if(node->linkedListVoid!=this) {
+ throw std::logic_error(String("node not on this list"));
+ }
+ newNode->linkedListVoid = this;
newNode->after = existingNode->after;
newNode->before = existingNode;
existingNode->after->before = newNode;
@@ -186,6 +192,10 @@ void LinkedListVoid::insertBefore(LinkedListVoidNode *node,
if(newNode->before!=0 || newNode->after!=0) {
throw std::logic_error(alreadyOnList);
}
+ if(node->linkedListVoid!=this) {
+ throw std::logic_error(String("node not on this list"));
+ }
+ newNode->linkedListVoid = this;
newNode->after = existingNode;
newNode->before = existingNode->before;
existingNode->before->after = newNode;
@@ -209,12 +219,15 @@ LinkedListVoidNode *LinkedListVoid::removeHead()
return node;
}
-void LinkedListVoid::remove(LinkedListVoidNode *listNode)
+void LinkedListVoid::remove(LinkedListVoidNode *node)
{
- LinkedListVoidNode *node = listNode;
if(node->before==0 || node->after==0) {
- throw std::logic_error(String("listNode not on list"));
+ throw std::logic_error(String("node not on list"));
}
+ if(node->linkedListVoid!=this) {
+ throw std::logic_error(String("node not on this list"));
+ }
+ node->linkedListVoid = 0;
LinkedListVoidNode *prev = node->before;
LinkedListVoidNode *next = node->after;
node->after = node->before = 0;
@@ -233,6 +246,7 @@ void LinkedListVoid::remove(void * object)
}
node = getNext(node);
}
+ throw std::logic_error(String("object not on this list"));
}
LinkedListVoidNode *LinkedListVoid::getHead()
@@ -249,12 +263,18 @@ LinkedListVoidNode *LinkedListVoid::getTail()
LinkedListVoidNode *LinkedListVoid::getNext(LinkedListVoidNode *listNode)
{
+ if(listNode->linkedListVoid!=this) {
+ throw std::logic_error(String("node not on this list"));
+ }
if(listNode->after==head) return 0;
return listNode->after;
}
LinkedListVoidNode *LinkedListVoid::getPrev(LinkedListVoidNode *listNode)
{
+ if(listNode->linkedListVoid!=this) {
+ throw std::logic_error(String("node not on this list"));
+ }
if(listNode->before==head) return 0;
return listNode->before;
}
diff --git a/pvDataApp/misc/linkedListVoid.h b/pvDataApp/misc/linkedListVoid.h
index 4abacac..d19c648 100644
--- a/pvDataApp/misc/linkedListVoid.h
+++ b/pvDataApp/misc/linkedListVoid.h
@@ -28,6 +28,7 @@ private:
void *object;
LinkedListVoidNode *before;
LinkedListVoidNode *after;
+ LinkedListVoid *linkedListVoid;
// do not implement the following
LinkedListVoidNode(const LinkedListVoidNode&);
LinkedListVoidNode & operator=(const LinkedListVoidNode&);
diff --git a/pvDataApp/misc/lock.h b/pvDataApp/misc/lock.h
index 6cb928d..70e7a2d 100644
--- a/pvDataApp/misc/lock.h
+++ b/pvDataApp/misc/lock.h
@@ -14,25 +14,25 @@
namespace epics { namespace pvData {
- class Mutex {
- public:
- Mutex() : id(epicsMutexMustCreate()){}
- ~Mutex() { epicsMutexDestroy(id) ;};
- void lock(){epicsMutexMustLock(id);}\
- void unlock(){epicsMutexUnlock(id);}
- private:
- epicsMutexId id;
- };
+class Mutex {
+public:
+ Mutex() : id(epicsMutexMustCreate()){}
+ ~Mutex() { epicsMutexDestroy(id) ;}
+ void lock(){epicsMutexMustLock(id);}
+ void unlock(){epicsMutexUnlock(id);}
+private:
+ epicsMutexId id;
+};
- class Lock : private NoDefaultMethods {
- public:
- explicit Lock(Mutex *pm)
- : mutexPtr(pm)
- {mutexPtr->lock();}
- ~Lock(){mutexPtr->unlock();}
- private:
- Mutex *mutexPtr;
- };
+class Lock : private NoDefaultMethods {
+public:
+ explicit Lock(Mutex *pm)
+ : mutexPtr(pm)
+ {mutexPtr->lock();}
+ ~Lock(){mutexPtr->unlock();}
+private:
+ Mutex *mutexPtr;
+};
}}
#endif /* LOCK_H */
diff --git a/pvDataApp/misc/pvType.h b/pvDataApp/misc/pvType.h
index b0fa1d3..5389366 100644
--- a/pvDataApp/misc/pvType.h
+++ b/pvDataApp/misc/pvType.h
@@ -10,16 +10,16 @@
namespace epics { namespace pvData {
- typedef signed char int8;
- typedef short int16;
- typedef int int32;
- typedef long long int64;
- typedef unsigned int uint32;
- typedef unsigned long long uint64;
+typedef signed char int8;
+typedef short int16;
+typedef int int32;
+typedef long long int64;
+typedef unsigned int uint32;
+typedef unsigned long long uint64;
- typedef std::string String;
- typedef std::string * StringBuilder;
- typedef String* StringArray;
+typedef std::string String;
+typedef std::string * StringBuilder;
+typedef String* StringArray;
}}
#endif /* PVTYPE_H */
diff --git a/pvDataApp/misc/requester.cpp b/pvDataApp/misc/requester.cpp
new file mode 100644
index 0000000..dd36d01
--- /dev/null
+++ b/pvDataApp/misc/requester.cpp
@@ -0,0 +1,20 @@
+/* requester.cpp */
+/**
+ * Copyright - See the COPYRIGHT that is included with this distribution.
+ * EPICS pvDataCPP is distributed subject to a Software License Agreement found
+ * in file LICENSE that is included with this distribution.
+ */
+#include
+#include "requester.h"
+namespace epics { namespace pvData {
+
+static std::string typeName[] = {
+ String("info"),
+ String("warning"),
+ String("error"),
+ String("fatalError")
+};
+
+StringArray messageTypeName = typeName;
+
+}}
diff --git a/pvDataApp/misc/requester.h b/pvDataApp/misc/requester.h
index ff3d7af..9f826c5 100644
--- a/pvDataApp/misc/requester.h
+++ b/pvDataApp/misc/requester.h
@@ -7,24 +7,22 @@
#include
#ifndef REQUESTER_H
#define REQUESTER_H
-#include "pvIntrospect.h"
+#include "pvType.h"
namespace epics { namespace pvData {
- class Requester;
-
- enum MessageType {
- infoMessage,warningMessage,errorMessage,fatalErrorMessage
- };
+class Requester;
- static std::string messageTypeName[] = {
- "info","warning","error","fatalError"
- };
-
- class Requester {
- public:
- virtual String getRequesterName() = 0;
- virtual void message(String message,MessageType messageType) = 0;
- };
+enum MessageType {
+ infoMessage,warningMessage,errorMessage,fatalErrorMessage
+};
+
+extern StringArray messageTypeName;
+
+class Requester {
+public:
+ virtual String getRequesterName() = 0;
+ virtual void message(String message,MessageType messageType) = 0;
+};
}}
#endif /* REQUESTER_H */
diff --git a/pvDataApp/misc/showConstructDestruct.cpp b/pvDataApp/misc/showConstructDestruct.cpp
index c39fcec..c6f6c61 100644
--- a/pvDataApp/misc/showConstructDestruct.cpp
+++ b/pvDataApp/misc/showConstructDestruct.cpp
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include "noDefaultMethods.h"
#include "lock.h"
@@ -62,6 +63,7 @@ ShowConstructDestruct::ShowConstructDestruct() {}
void ShowConstructDestruct::constuctDestructTotals(FILE *fd)
{
+ getShowConstructDestruct(); // make it initialize
Lock xx(globalMutex);
ListNode *node = list->getHead();
while(node!=0) {
@@ -80,8 +82,33 @@ void ShowConstructDestruct::constuctDestructTotals(FILE *fd)
void ShowConstructDestruct::registerCallback(ConstructDestructCallback *callback)
{
+ static ConstructDestructCallback *listCallback = 0;
+ static ConstructDestructCallback *listNodeCallback = 0;
Lock xx(globalMutex);
- ListNode *listNode = new ListNode(callback);
+ ListNode *listNode = 0;
+ if(list==0) {
+ if(callback->getConstructName().compare("linkedListNode")==0) {
+ listNodeCallback = callback;
+ } else if(callback->getConstructName().compare("linkedList")==0) {
+ listCallback = callback;
+ } else {
+ throw std::logic_error(String("ShowConstructDestruct::registerCallback"));
+ }
+ return;
+ }
+ if(listCallback!=0) {
+ if(listNodeCallback==0) {
+ throw std::logic_error(String(
+ "ShowConstructDestruct::registerCallback expected listNodeCallback!=0"));
+ }
+ listNode = new ListNode(listNodeCallback);
+ list->addTail(listNode);
+ listNode = new ListNode(listCallback);
+ list->addTail(listNode);
+ listCallback = 0;
+ listNodeCallback = 0;
+ }
+ listNode = new ListNode(callback);
list->addTail(listNode);
}
@@ -91,9 +118,9 @@ ShowConstructDestruct * getShowConstructDestruct()
Lock xx(&mutex);
if(pShowConstructDestruct==0) {
globalMutex = new Mutex();
- list = new List();
pShowConstructDestruct = new ShowConstructDestruct();
- }
+ list = new List();
+ }
return pShowConstructDestruct;
}
diff --git a/pvDataApp/misc/showConstructDestruct.h b/pvDataApp/misc/showConstructDestruct.h
index e7b1c54..f8fe20c 100644
--- a/pvDataApp/misc/showConstructDestruct.h
+++ b/pvDataApp/misc/showConstructDestruct.h
@@ -40,8 +40,8 @@ private:
class ShowConstructDestruct : private NoDefaultMethods {
public:
- static void constuctDestructTotals(FILE *fd);
- static void registerCallback(ConstructDestructCallback *callback);
+ void constuctDestructTotals(FILE *fd);
+ void registerCallback(ConstructDestructCallback *callback);
private:
ShowConstructDestruct();
friend ShowConstructDestruct* getShowConstructDestruct();
diff --git a/pvDataApp/misc/thread.cpp b/pvDataApp/misc/thread.cpp
index 4c13f19..5c0dbff 100644
--- a/pvDataApp/misc/thread.cpp
+++ b/pvDataApp/misc/thread.cpp
@@ -9,6 +9,7 @@
#include
#include
#include
+#include
#include
#include
@@ -48,9 +49,7 @@ typedef LinkedList ThreadList;
static volatile int64 totalConstruct = 0;
static volatile int64 totalDestruct = 0;
static Mutex *globalMutex = 0;
-static void addThread(Thread *thread);
-static void removeThread(Thread *thread);
-static ThreadList *list;
+static ThreadList *threadList;
static int64 getTotalConstruct()
{
@@ -72,7 +71,7 @@ static void init()
Lock xx(&mutex);
if(globalMutex==0) {
globalMutex = new Mutex();
- list = new ThreadList();
+ threadList = new ThreadList();
pConstructDestructCallback = new ConstructDestructCallback(
String("thread"),
getTotalConstruct,getTotalDestruct,0);
@@ -96,38 +95,37 @@ int ThreadPriorityFunc::getEpicsPriority(ThreadPriority threadPriority) {
extern "C" void myFunc ( void * pPvt );
-class Runnable : public ThreadReady {
+class ThreadPvt {
public:
- Runnable(Thread *thread,String name,
- ThreadPriority priority, RunnableReady *runnable);
- virtual ~Runnable();
- Thread *start();
+ ThreadPvt(Thread *thread,String name,
+ ThreadPriority priority, Runnable*runnable);
+ virtual ~ThreadPvt();
void ready();
public: // only used within this source module
Thread *thread;
String name;
ThreadPriority priority;
- RunnableReady *runnable;
- Event waitStart;
+ Runnable *runnable;
bool isReady;
+ ThreadListElement *threadListElement;
+ Event *waitDone;
epicsThreadId id;
};
extern "C" void myFunc ( void * pPvt )
{
- Runnable *runnable = (Runnable *)pPvt;
- runnable->waitStart.signal();
- addThread(runnable->thread);
- runnable->runnable->run(runnable);
- removeThread(runnable->thread);
+ ThreadPvt *threadPvt = (ThreadPvt *)pPvt;
+ threadPvt->runnable->run();
+ threadPvt->waitDone->signal();
}
-Runnable::Runnable(Thread *thread,String name,
- ThreadPriority priority, RunnableReady *runnable)
+ThreadPvt::ThreadPvt(Thread *thread,String name,
+ ThreadPriority priority, Runnable *runnable)
: thread(thread),name(name),priority(priority),
runnable(runnable),
- waitStart(eventEmpty),
isReady(false),
+ threadListElement(new ThreadListElement(thread)),
+ waitDone(new Event()),
id(epicsThreadCreate(
name.c_str(),
epicsPriority[priority],
@@ -136,32 +134,35 @@ Runnable::Runnable(Thread *thread,String name,
{
init();
Lock xx(globalMutex);
+ threadList->addTail(threadListElement->node);
totalConstruct++;
}
-Runnable::~Runnable()
+ThreadPvt::~ThreadPvt()
{
+ bool result = waitDone->wait(2.0);
+ if(!result) {
+ throw std::logic_error(String("delete thread but run did not return"));
+ String message("destroy thread ");
+ message += thread->getName();
+ message += " but run did not return";
+ throw std::logic_error(message);
+ }
+ if(!threadListElement->node->isOnList()) {
+ String message("destroy thread ");
+ message += thread->getName();
+ message += " is not on threadlist";
+ throw std::logic_error(message);
+ }
+ threadList->remove(threadListElement->node);
+ delete waitDone;
+ delete threadListElement;
Lock xx(globalMutex);
totalDestruct++;
}
-
-Thread * Runnable::start()
-{
- if(!waitStart.wait(10.0)) {
- fprintf(stderr,"thread %s did not call ready\n",thread->getName().c_str());
- }
- return thread;
-}
-
-
-void Runnable::ready()
-{
- waitStart.signal();
-}
-
-Thread::Thread(String name,ThreadPriority priority,RunnableReady *runnableReady)
-: pImpl(new Runnable(this,name,priority,runnableReady))
+Thread::Thread(String name,ThreadPriority priority,Runnable *runnable)
+: pImpl(new ThreadPvt(this,name,priority,runnable))
{
}
@@ -176,12 +177,6 @@ ConstructDestructCallback *Thread::getConstructDestructCallback()
return pConstructDestructCallback;
}
-void Thread::start()
-{
- pImpl->start();
-}
-
-
void Thread::sleep(double seconds)
{
epicsThreadSleep(seconds);;
@@ -201,38 +196,15 @@ void Thread::showThreads(StringBuilder buf)
{
init();
Lock xx(globalMutex);
- ThreadListNode *node = list->getHead();
+ ThreadListNode *node = threadList->getHead();
while(node!=0) {
Thread *thread = node->getObject()->thread;
*buf += thread->getName();
*buf += " ";
*buf += threadPriorityNames[thread->getPriority()];
*buf += "\n";
- node = list->getNext(node);
+ node = threadList->getNext(node);
}
}
-void addThread(Thread *thread)
-{
- Lock xx(globalMutex);
- ThreadListElement *element = new ThreadListElement(thread);
- list->addTail(element->node);
-}
-
-void removeThread(Thread *thread)
-{
- Lock xx(globalMutex);
- ThreadListNode *node = list->getHead();
- while(node!=0) {
- if(node->getObject()->thread==thread) {
- list->remove(node);
- delete node;
- return;
- }
- node = list->getNext(node);
- }
- fprintf(stderr,"removeThread but thread %s did not in list\n",
- thread->getName().c_str());
-}
-
}}
diff --git a/pvDataApp/misc/thread.h b/pvDataApp/misc/thread.h
index bfb1407..664a20d 100644
--- a/pvDataApp/misc/thread.h
+++ b/pvDataApp/misc/thread.h
@@ -8,6 +8,7 @@
#define THREAD_H
#include "noDefaultMethods.h"
#include "pvType.h"
+#include "showConstructDestruct.h"
namespace epics { namespace pvData {
@@ -27,32 +28,25 @@ public:
static int getEpicsPriority(ThreadPriority threadPriority);
};
-
-class ThreadReady {
+class Runnable{
public:
- virtual void ready() = 0;
-};
-
-class RunnableReady {
-public:
- virtual void run(ThreadReady *threadReady) = 0;
+ virtual void run() = 0;
};
class Thread;
class Thread : private NoDefaultMethods {
public:
- Thread(String name,ThreadPriority priority,RunnableReady *runnableReady);
+ Thread(String name,ThreadPriority priority,Runnable *runnable);
~Thread();
static ConstructDestructCallback *getConstructDestructCallback();
- void start();
String getName();
ThreadPriority getPriority();
static void showThreads(StringBuilder buf);
static void sleep(double seconds);
private:
- class Runnable *pImpl;
- friend class Runnable;
+ class ThreadPvt *pImpl;
+ friend class ThreadPvt;
};
}}
diff --git a/pvDataApp/misc/timeStamp.cpp b/pvDataApp/misc/timeStamp.cpp
index d147a2c..064001e 100644
--- a/pvDataApp/misc/timeStamp.cpp
+++ b/pvDataApp/misc/timeStamp.cpp
@@ -24,8 +24,44 @@ int64 posixEpochAtEpicsEpoch = POSIX_TIME_AT_EPICS_EPOCH;
TimeStamp::TimeStamp(int64 secondsPastEpoch,int32 nanoSeconds)
: secondsPastEpoch(secondsPastEpoch),nanoSeconds(nanoSeconds)
-{}
+{
+ normalize();
+}
+void TimeStamp::normalize()
+{
+ if(nanoSeconds>=0 && nanoSeconds=nanoSecPerSec) {
+ nanoSeconds -= nanoSecPerSec;
+ secondsPastEpoch++;
+ }
+ while(nanoSeconds<0) {
+ nanoSeconds += nanoSecPerSec;
+ secondsPastEpoch--;
+ }
+}
+
+void TimeStamp::fromTime_t(const time_t & tt)
+{
+ epicsTimeStamp epicsTime;
+ epicsTimeFromTime_t(&epicsTime,tt);
+ secondsPastEpoch = epicsTime.secPastEpoch + posixEpochAtEpicsEpoch;
+ nanoSeconds = epicsTime.nsec;
+}
+
+void TimeStamp::toTime_t(time_t &tt) const
+{
+ epicsTimeStamp epicsTime;
+ epicsTime.secPastEpoch = secondsPastEpoch-posixEpochAtEpicsEpoch;
+ epicsTime.nsec = nanoSeconds;
+ epicsTimeToTime_t(&tt,&epicsTime);
+}
+
+void TimeStamp::put(int64 milliseconds)
+{
+ secondsPastEpoch = milliseconds/1000;
+ nanoSeconds = (milliseconds%1000)*1000000;
+}
void TimeStamp::getCurrent()
{
@@ -144,12 +180,4 @@ int64 TimeStamp::getMilliseconds()
return secondsPastEpoch*1000 + nanoSeconds/1000000;
}
-void TimeStamp::put(int64 milliseconds)
-{
- secondsPastEpoch = milliseconds/1000;
- nanoSeconds = (milliseconds%1000)*1000000;
-}
-
-
-
}}
diff --git a/pvDataApp/misc/timeStamp.h b/pvDataApp/misc/timeStamp.h
index f95654d..4398acc 100644
--- a/pvDataApp/misc/timeStamp.h
+++ b/pvDataApp/misc/timeStamp.h
@@ -6,6 +6,7 @@
*/
#ifndef TIMESTAMP_H
#define TIMESTAMP_H
+#include
#include "epicsTime.h"
#include "pvType.h"
@@ -20,10 +21,12 @@ class TimeStamp {
public:
TimeStamp()
:secondsPastEpoch(0),nanoSeconds(0) {}
+ TimeStamp(int64 secondsPastEpoch,int32 nanoSeconds = 0);
//default constructors and destructor are OK
//This class should not be extended
- TimeStamp(int64 secondsPastEpoch,int32 nanoSeconds = 0);
- TimeStamp(epicsTimeStamp &epics);
+ void normalize();
+ void fromTime_t(const time_t &);
+ void toTime_t(time_t &) const;
int64 getSecondsPastEpoch() const {return secondsPastEpoch;}
int64 getEpicsSecondsPastEpoch() const {
return secondsPastEpoch - posixEpochAtEpicsEpoch;
@@ -32,7 +35,9 @@ public:
void put(int64 secondsPastEpoch,int32 nanoSeconds = 0) {
this->secondsPastEpoch = secondsPastEpoch;
this->nanoSeconds = nanoSeconds;
+ normalize();
}
+ void put(int64 milliseconds);
void getCurrent();
double toSeconds() const ;
bool operator==(TimeStamp const &) const;
@@ -46,10 +51,7 @@ public:
TimeStamp & operator-=(int64 seconds);
TimeStamp & operator+=(double seconds);
TimeStamp & operator-=(double seconds);
- // milliseconds since epoch
- int64 getMilliseconds();
- void put(int64 milliseconds);
-
+ int64 getMilliseconds(); // milliseconds since epoch
private:
static int64 diffInt(TimeStamp const &left,TimeStamp const &right );
int64 secondsPastEpoch;
diff --git a/pvDataApp/misc/timer.cpp b/pvDataApp/misc/timer.cpp
index 5fbd531..48231ec 100644
--- a/pvDataApp/misc/timer.cpp
+++ b/pvDataApp/misc/timer.cpp
@@ -87,14 +87,14 @@ ConstructDestructCallback * Timer::getConstructDestructCallback()
class TimerNodePvt;
-typedef LinkedListNode ListNode;
-typedef LinkedList List;
+typedef LinkedListNode TimerListNode;
+typedef LinkedList TimerList;
class TimerNodePvt {
public:
TimerNode *timerNode;
TimerCallback *callback;
- ListNode *listNode;
+ TimerListNode *timerListNode;
TimeStamp timeToRun;
TimerPvt *timerPvt;
double period;
@@ -104,65 +104,63 @@ public:
TimerNodePvt::TimerNodePvt(TimerNode *timerNode,TimerCallback *callback)
: timerNode(timerNode),callback(callback),
- listNode(new ListNode(this)),timeToRun(TimeStamp()),
+ timerListNode(new TimerListNode(this)),timeToRun(TimeStamp()),
timerPvt(0), period(0.0)
{}
TimerNodePvt::~TimerNodePvt()
{
- delete listNode;
+ delete timerListNode;
}
-struct TimerPvt : public RunnableReady {
+struct TimerPvt : public Runnable{
public:
TimerPvt(String threadName,ThreadPriority priority);
~TimerPvt();
- virtual void run(ThreadReady *threadReady);
+ virtual void run();
public: // only used by this source module
- List *list;
+ TimerList *timerList;
Mutex mutex;
Event *waitForWork;
Event *waitForDone;
- Thread *thread;
volatile bool alive;
+ Thread *thread;
};
TimerPvt::TimerPvt(String threadName,ThreadPriority priority)
-: list(new List()),
+: timerList(new TimerList()),
mutex(Mutex()),
- waitForWork(new Event(eventEmpty)),
- waitForDone(new Event(eventEmpty)),
- thread(new Thread(threadName,priority,this)),
- alive(true)
-{
- thread->start();
-}
+ waitForWork(new Event(false)),
+ waitForDone(new Event(false)),
+ alive(true),
+ thread(new Thread(threadName,priority,this))
+{}
TimerPvt::~TimerPvt()
{
delete thread;
delete waitForDone;
delete waitForWork;
- delete list;
+ delete timerList;
}
static void addElement(TimerPvt *timer,TimerNodePvt *node)
{
- List *list = timer->list;
- ListNode *nextNode = list->getHead();
+ TimerList *timerList = timer->timerList;
+ TimerListNode *nextNode = timerList->getHead();
if(nextNode==0) {
- list->addTail(node->listNode);
+ timerList->addTail(node->timerListNode);
return;
}
while(true) {
- TimerNodePvt *listNode = nextNode->getObject();
- if((node->timeToRun)<(listNode->timeToRun)) {
- list->insertBefore(listNode->listNode,node->listNode);
+ TimerNodePvt *timerListNode = nextNode->getObject();
+ if((node->timeToRun)<(timerListNode->timeToRun)) {
+ timerList->insertBefore(timerListNode->timerListNode,node->timerListNode);
return;
}
- nextNode = list->getNext(listNode->listNode);
+ nextNode = timerList->getNext(timerListNode->timerListNode);
if(nextNode==0) {
- list->addTail(node->listNode);
+ timerList->addTail(node->timerListNode);
return;
}
}
@@ -177,31 +175,22 @@ TimerNode::TimerNode(TimerCallback *callback)
totalNodeConstruct++;
}
-TimerNode *TimerNode::create(TimerCallback *callback)
-{
- return new TimerNode(callback);
-}
TimerNode::~TimerNode()
{
+ cancel();
delete pImpl;
Lock xx(globalMutex);
totalNodeDestruct++;
}
-void TimerNode::destroy()
-{
- cancel();
- delete this;
-}
-
void TimerNode::cancel()
{
TimerPvt *timerPvt = pImpl->timerPvt;
if(timerPvt==0) return;
Lock xx(&timerPvt->mutex);
if(pImpl->timerPvt==0) return;
- pImpl->timerPvt->list->remove(pImpl);
+ pImpl->timerPvt->timerList->remove(pImpl);
pImpl->timerPvt = 0;
}
@@ -210,13 +199,12 @@ bool TimerNode::isScheduled()
TimerPvt *pvt = pImpl->timerPvt;
if(pvt==0) return false;
Lock xx(&pvt->mutex);
- return pImpl->listNode->isOnList();
+ return pImpl->timerListNode->isOnList();
}
-void TimerPvt::run(ThreadReady *threadReady)
+void TimerPvt::run()
{
- threadReady->ready();
TimeStamp currentTime;
while(alive) {
currentTime.getCurrent();
@@ -225,25 +213,25 @@ void TimerPvt::run(ThreadReady *threadReady)
TimerNodePvt *nodeToCall = 0;
{
Lock xx(&mutex);
- ListNode *listNode = list->getHead();
- if(listNode!=0) {
- TimerNodePvt *timerNodePvt = listNode->getObject();
+ TimerListNode *timerListNode = timerList->getHead();
+ if(timerListNode!=0) {
+ TimerNodePvt *timerNodePvt = timerListNode->getObject();
timeToRun = &timerNodePvt->timeToRun;
double diff = TimeStamp::diff(
*timeToRun,currentTime);
if(diff<=0.0) {
nodeToCall = timerNodePvt;
- list->removeHead();
+ timerList->removeHead();
period = timerNodePvt->period;
- if(period>0) {
+ if(period>0.0) {
timerNodePvt->timeToRun += period;
addElement(this,timerNodePvt);
} else {
timerNodePvt->timerPvt = 0;
}
- listNode = list->getHead();
- if(listNode!=0) {
- timerNodePvt = listNode->getObject();
+ timerListNode = timerList->getHead();
+ if(timerListNode!=0) {
+ timerNodePvt = timerListNode->getObject();
timeToRun = &timerNodePvt->timeToRun;
} else {
timeToRun = 0;
@@ -273,31 +261,21 @@ Timer::Timer(String threadName, ThreadPriority priority)
totalTimerConstruct++;
}
-Timer * Timer::create(String threadName, ThreadPriority priority)
-{
- return new Timer(threadName,priority);
-}
-
Timer::~Timer() {
- delete pImpl;
- Lock xx(globalMutex);
- totalTimerDestruct++;
-}
-
-void Timer::destroy()
-{
{
Lock xx(&pImpl->mutex);
pImpl->alive = false;
- pImpl->waitForWork->signal();
- pImpl->waitForDone->wait();
}
- List *list = pImpl->list;
- ListNode *node = 0;
- while((node = list->removeHead())!=0) {
+ pImpl->waitForWork->signal();
+ pImpl->waitForDone->wait();
+ TimerList *timerList = pImpl->timerList;
+ TimerListNode *node = 0;
+ while((node = timerList->removeHead())!=0) {
node->getObject()->callback->timerStopped();
}
- delete this;
+ delete pImpl;
+ Lock xx(globalMutex);
+ totalTimerDestruct++;
}
void Timer::scheduleAfterDelay(TimerNode *timerNode,double delay)
@@ -307,7 +285,7 @@ void Timer::scheduleAfterDelay(TimerNode *timerNode,double delay)
void Timer::schedulePeriodic(TimerNode *timerNode,double delay,double period)
{
TimerNodePvt *timerNodePvt = timerNode->pImpl;
- if(timerNodePvt->listNode->isOnList()) {
+ if(timerNodePvt->timerListNode->isOnList()) {
throw std::logic_error(String("already queued"));
}
if(!pImpl->alive) {
@@ -323,7 +301,7 @@ void Timer::schedulePeriodic(TimerNode *timerNode,double delay,double period)
Lock xx(&pImpl->mutex);
timerNodePvt->timerPvt = pImpl;
addElement(pImpl,timerNodePvt);
- TimerNodePvt *first = pImpl->list->getHead()->getObject();
+ TimerNodePvt *first = pImpl->timerList->getHead()->getObject();
if(first==timerNodePvt) isFirst = true;
}
if(isFirst) pImpl->waitForWork->signal();
diff --git a/pvDataApp/misc/timer.h b/pvDataApp/misc/timer.h
index f71d3fa..00f3e88 100644
--- a/pvDataApp/misc/timer.h
+++ b/pvDataApp/misc/timer.h
@@ -27,28 +27,24 @@ public:
class TimerNode : private NoDefaultMethods {
public:
+ TimerNode(TimerCallback *timerCallback);
+ ~TimerNode();
static ConstructDestructCallback *getConstructDestructCallback();
- static TimerNode *create(TimerCallback *timerCallback);
- void destroy();
void cancel();
bool isScheduled();
private:
- TimerNode(TimerCallback *timerCallback);
- ~TimerNode();
class TimerNodePvt *pImpl;
friend class Timer;
};
class Timer : private NoDefaultMethods {
public:
+ Timer(String threadName, ThreadPriority priority);
+ ~Timer();
static ConstructDestructCallback *getConstructDestructCallback();
- static Timer * create(String threadName, ThreadPriority priority);
- void destroy();
void scheduleAfterDelay(TimerNode *timerNode,double delay);
void schedulePeriodic(TimerNode *timerNode,double delay,double period);
private:
- Timer(String threadName, ThreadPriority priority);
- ~Timer();
class TimerPvt *pImpl;
friend class TimerNode;
};
diff --git a/pvDataApp/miscTest/testLinkedList.cpp b/pvDataApp/miscTest/testLinkedList.cpp
index f05cb0f..0ab3ffc 100644
--- a/pvDataApp/miscTest/testLinkedList.cpp
+++ b/pvDataApp/miscTest/testLinkedList.cpp
@@ -352,7 +352,7 @@ static void testTimeLocked(FILE *auxFd) {
}
typedef std::list stdList;
-static void testArrayListTime(FILE *auxFd) {
+static void testStdListTime(FILE *auxFd) {
TimeStamp startTime;
TimeStamp endTime;
int numNodes = 1000;
@@ -362,7 +362,7 @@ static void testArrayListTime(FILE *auxFd) {
for(int i=0; iconstuctDestructTotals(fd);
return (0);
}
diff --git a/pvDataApp/miscTest/testThread.cpp b/pvDataApp/miscTest/testThread.cpp
index c54ed55..35e5b15 100644
--- a/pvDataApp/miscTest/testThread.cpp
+++ b/pvDataApp/miscTest/testThread.cpp
@@ -43,7 +43,7 @@ private:
Basic::Basic(Executor *executor)
: executor(executor),
executorNode(executor->createNode(this)),
- wait(new Event(eventEmpty))
+ wait(new Event())
{
}
@@ -55,7 +55,7 @@ void Basic::run()
{
executor->execute(executorNode);
bool result = wait->wait();
- if(result==false) printf("basic::run wait returned true\n");
+ if(result==false) printf("basic::run wait returned false\n");
}
void Basic::command()
@@ -65,14 +65,14 @@ void Basic::command()
static void testBasic(FILE *fd) {
- Executor *executor = Executor::create(String("basic"),middlePriority);
+ Executor *executor = new Executor(String("basic"),middlePriority);
Basic *basic = new Basic(executor);
basic->run();
delete basic;
String buf("");
Thread::showThreads(&buf);
fprintf(fd,"threads\n%s\n",buf.c_str());
- executor->destroy();
+ delete executor;
}
class MyFunc : public TimeFunctionRequester {
@@ -89,7 +89,7 @@ private:
};
static void testThreadContext(FILE *fd,FILE *auxFd) {
- Executor *executor = Executor::create(String("basic"),middlePriority);
+ Executor *executor = new Executor(String("basic"),middlePriority);
Basic *basic = new Basic(executor);
MyFunc myFunc(basic);
TimeFunction timeFunction(&myFunc);
@@ -97,7 +97,7 @@ static void testThreadContext(FILE *fd,FILE *auxFd) {
perCall *= 1e6;
fprintf(auxFd,"time per call %f microseconds\n",perCall);
delete basic;
- executor->destroy();
+ delete executor;
}
int main(int argc, char *argv[]) {
diff --git a/pvDataApp/miscTest/testTimeStamp.cpp b/pvDataApp/miscTest/testTimeStamp.cpp
index 484174c..c148284 100644
--- a/pvDataApp/miscTest/testTimeStamp.cpp
+++ b/pvDataApp/miscTest/testTimeStamp.cpp
@@ -14,7 +14,9 @@
#include
#include
#include
+#include
#include
+#include
#include
#include
@@ -32,6 +34,30 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
current.getSecondsPastEpoch(),
current.getNanoSeconds(),
current.getMilliseconds());
+ time_t tt;
+ current.toTime_t(tt);
+ struct tm ctm;
+ memcpy(&ctm,localtime(&tt),sizeof(struct tm));
+ fprintf(auxfd,
+ "%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s\n",
+ ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
+ ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
+ current.getNanoSeconds(),
+ (ctm.tm_isdst==0) ? "false" : "true");
+ tt = time(&tt);
+ current.fromTime_t(tt);
+ fprintf(auxfd,"fromTime_t\ncurrent %lli %i milliSec %lli\n",
+ current.getSecondsPastEpoch(),
+ current.getNanoSeconds(),
+ current.getMilliseconds());
+ current.toTime_t(tt);
+ memcpy(&ctm,localtime(&tt),sizeof(struct tm));
+ fprintf(auxfd,
+ "%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s\n",
+ ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
+ ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
+ current.getNanoSeconds(),
+ (ctm.tm_isdst==0) ? "false" : "true");
TimeStamp right;
TimeStamp left;
right.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
diff --git a/pvDataApp/miscTest/testTimer.cpp b/pvDataApp/miscTest/testTimer.cpp
index f5b1bc5..062e15c 100644
--- a/pvDataApp/miscTest/testTimer.cpp
+++ b/pvDataApp/miscTest/testTimer.cpp
@@ -33,12 +33,12 @@ class MyCallback : public TimerCallback {
public:
MyCallback(String name,FILE *fd,FILE *auxfd,Event *wait)
: name(name),fd(fd),auxfd(auxfd),wait(wait),
- timerNode(TimerNode::create(this)),timeStamp(TimeStamp())
+ timerNode(new TimerNode(this)),timeStamp(TimeStamp())
{
}
~MyCallback()
{
- timerNode->destroy();
+ delete timerNode;
}
virtual void callback()
{
@@ -64,9 +64,9 @@ static void testBasic(FILE *fd, FILE *auxfd)
{
String one("one");
String two("two");
- Event *eventOne = new Event(eventEmpty);
- Event *eventTwo = new Event(eventEmpty);
- Timer *timer = Timer::create(String("timer"),middlePriority);
+ Event *eventOne = new Event();
+ Event *eventTwo = new Event();
+ Timer *timer = new Timer(String("timer"),middlePriority);
MyCallback *callbackOne = new MyCallback(
one,fd,auxfd,eventOne);
MyCallback *callbackTwo = new MyCallback(
@@ -83,11 +83,11 @@ static void testBasic(FILE *fd, FILE *auxfd)
diff = TimeStamp::diff(
callbackTwo->getTimeStamp(),currentTimeStamp);
fprintf(auxfd,"two requested %f diff %f seconds\n",twoDelay,diff);
- timer->destroy();
- delete callbackOne;
+ delete timer;
delete callbackTwo;
- delete eventOne;
+ delete callbackOne;
delete eventTwo;
+ delete eventOne;
}
int main(int argc, char *argv[]) {
diff --git a/pvDataApp/pv/MakefileBack b/pvDataApp/pv/MakefileBack
deleted file mode 100644
index 88392ec..0000000
--- a/pvDataApp/pv/MakefileBack
+++ /dev/null
@@ -1,15 +0,0 @@
-TOP=../..
-
-include $(TOP)/configure/CONFIG
-
-INC += pvIntrospect.h
-INC += bitSet.h
-INC += requester.h
-INC += byteBuffer.h
-INC += serialize.h
-INC += pvData.h
-
-include $(TOP)/configure/RULES
-#----------------------------------------
-# ADD RULES AFTER THIS LINE
-
diff --git a/pvDataApp/pv/convert.h b/pvDataApp/pv/convert.h
index 2800b91..1544bc0 100644
--- a/pvDataApp/pv/convert.h
+++ b/pvDataApp/pv/convert.h
@@ -13,76 +13,76 @@
namespace epics { namespace pvData {
- class Convert : NoDefaultMethods {
- public:
- Convert();
- ~Convert();
- void getFullName(StringBuilder buf,PVField *pvField);
- bool equals(PVField *a,PVField *b);
- void getString(StringBuilder buf,PVField * pvField,int indentLevel);
- void getString(StringBuilder buf,PVField *pvField);
- void fromString(PVScalar *pv, String from);
- int fromString(PVScalarArray *pv, String from);
- int fromStringArray(PVScalarArray *pv, int offset, int length,
- StringArray from, int fromOffset);
- int toStringArray(PVScalarArray *pv, int offset, int length,
- StringArray to, int toOffset);
- bool isCopyCompatible(FieldConstPtr from, FieldConstPtr to);
- void copy(PVField *from,PVField *to);
- bool isCopyScalarCompatible(
- ScalarConstPtr from, ScalarConstPtr to);
- void copyScalar(PVScalar *from, PVScalar *to);
- bool isCopyScalarArrayCompatible(ScalarArrayConstPtr from,
- ScalarArrayConstPtr to);
- int copyScalarArray(PVScalarArray *from, int offset,
- PVScalarArray *to, int toOffset, int length);
- bool isCopyStructureCompatible(
- StructureConstPtr from, StructureConstPtr to);
- void copyStructure(PVStructure *from, PVStructure *to);
- bool isCopyStructureArrayCompatible(
- StructureArrayConstPtr from, StructureArrayConstPtr to);
- void copyStructureArray(
- PVStructureArray *from, PVStructureArray *to);
- int8 toByte(PVScalar *pv);
- int16 toShort(PVScalar *pv);
- int32 toInt(PVScalar *pv);
- int64 toLong(PVScalar *pv);
- float toFloat(PVScalar *pv);
- double toDouble(PVScalar *pv);
- void fromByte(PVScalar *pv,int8 from);
- void fromShort(PVScalar *pv,int16 from);
- void fromInt(PVScalar *pv, int32 from);
- void fromLong(PVScalar *pv, int64 from);
- void fromFloat(PVScalar* pv, float from);
- void fromDouble(PVScalar *pv, double from);
- int toByteArray(PVScalarArray *pv, int offset, int length,
- ByteArray to, int toOffset);
- int toShortArray(PVScalarArray *pv, int offset, int length,
- ShortArray to, int toOffset);
- int toIntArray(PVScalarArray *pv, int offset, int length,
- IntArray to, int toOffset);
- int toLongArray(PVScalarArray *pv, int offset, int length,
- LongArray to, int toOffset);
- int toFloatArray(PVScalarArray *pv, int offset, int length,
- FloatArray to, int toOffset);
- int toDoubleArray(PVScalarArray *pv, int offset, int length,
- DoubleArray to, int toOffset);
- int fromByteArray(PVScalarArray *pv, int offset, int length,
- ByteArray from, int fromOffset);
- int fromShortArray(PVScalarArray *pv, int offset, int length,
- ShortArray from, int fromOffset);
- int fromIntArray(PVScalarArray *pv, int offset, int length,
- IntArray from, int fromOffset);
- int fromLongArray(PVScalarArray *pv, int offset, int length,
- LongArray from, int fromOffset);
- int fromFloatArray(PVScalarArray *pv, int offset, int length,
- FloatArray from, int fromOffset);
- int fromDoubleArray(PVScalarArray *pv, int offset, int length,
- DoubleArray from, int fromOffset);
- void newLine(StringBuilder buf, int indentLevel);
- };
+class Convert : NoDefaultMethods {
+public:
+ Convert();
+ ~Convert();
+ void getFullName(StringBuilder buf,PVField *pvField);
+ bool equals(PVField *a,PVField *b);
+ void getString(StringBuilder buf,PVField * pvField,int indentLevel);
+ void getString(StringBuilder buf,PVField *pvField);
+ void fromString(PVScalar *pv, String from);
+ int fromString(PVScalarArray *pv, String from);
+ int fromStringArray(PVScalarArray *pv, int offset, int length,
+ StringArray from, int fromOffset);
+ int toStringArray(PVScalarArray *pv, int offset, int length,
+ StringArray to, int toOffset);
+ bool isCopyCompatible(FieldConstPtr from, FieldConstPtr to);
+ void copy(PVField *from,PVField *to);
+ bool isCopyScalarCompatible(
+ ScalarConstPtr from, ScalarConstPtr to);
+ void copyScalar(PVScalar *from, PVScalar *to);
+ bool isCopyScalarArrayCompatible(ScalarArrayConstPtr from,
+ ScalarArrayConstPtr to);
+ int copyScalarArray(PVScalarArray *from, int offset,
+ PVScalarArray *to, int toOffset, int length);
+ bool isCopyStructureCompatible(
+ StructureConstPtr from, StructureConstPtr to);
+ void copyStructure(PVStructure *from, PVStructure *to);
+ bool isCopyStructureArrayCompatible(
+ StructureArrayConstPtr from, StructureArrayConstPtr to);
+ void copyStructureArray(
+ PVStructureArray *from, PVStructureArray *to);
+ int8 toByte(PVScalar *pv);
+ int16 toShort(PVScalar *pv);
+ int32 toInt(PVScalar *pv);
+ int64 toLong(PVScalar *pv);
+ float toFloat(PVScalar *pv);
+ double toDouble(PVScalar *pv);
+ void fromByte(PVScalar *pv,int8 from);
+ void fromShort(PVScalar *pv,int16 from);
+ void fromInt(PVScalar *pv, int32 from);
+ void fromLong(PVScalar *pv, int64 from);
+ void fromFloat(PVScalar* pv, float from);
+ void fromDouble(PVScalar *pv, double from);
+ int toByteArray(PVScalarArray *pv, int offset, int length,
+ ByteArray to, int toOffset);
+ int toShortArray(PVScalarArray *pv, int offset, int length,
+ ShortArray to, int toOffset);
+ int toIntArray(PVScalarArray *pv, int offset, int length,
+ IntArray to, int toOffset);
+ int toLongArray(PVScalarArray *pv, int offset, int length,
+ LongArray to, int toOffset);
+ int toFloatArray(PVScalarArray *pv, int offset, int length,
+ FloatArray to, int toOffset);
+ int toDoubleArray(PVScalarArray *pv, int offset, int length,
+ DoubleArray to, int toOffset);
+ int fromByteArray(PVScalarArray *pv, int offset, int length,
+ ByteArray from, int fromOffset);
+ int fromShortArray(PVScalarArray *pv, int offset, int length,
+ ShortArray from, int fromOffset);
+ int fromIntArray(PVScalarArray *pv, int offset, int length,
+ IntArray from, int fromOffset);
+ int fromLongArray(PVScalarArray *pv, int offset, int length,
+ LongArray from, int fromOffset);
+ int fromFloatArray(PVScalarArray *pv, int offset, int length,
+ FloatArray from, int fromOffset);
+ int fromDoubleArray(PVScalarArray *pv, int offset, int length,
+ DoubleArray from, int fromOffset);
+ void newLine(StringBuilder buf, int indentLevel);
+};
- extern Convert * getConvert();
+extern Convert * getConvert();
}}
#endif /* CONVERT_H */
diff --git a/pvDataApp/pv/pvData.h b/pvDataApp/pv/pvData.h
index 37c2f5b..d190038 100644
--- a/pvDataApp/pv/pvData.h
+++ b/pvDataApp/pv/pvData.h
@@ -17,510 +17,510 @@
#include "showConstructDestruct.h"
namespace epics { namespace pvData {
- class PVAuxInfo;
- class PostHandler;
+class PVAuxInfo;
+class PostHandler;
- class PVField;
- class PVScalar;
- class PVBoolean;
- class PVByte;
- class PVShort;
- class PVInt;
- class PVLong;
- class PVFloat;
- class PVDouble;
- class PVString;
+class PVField;
+class PVScalar;
+class PVBoolean;
+class PVByte;
+class PVShort;
+class PVInt;
+class PVLong;
+class PVFloat;
+class PVDouble;
+class PVString;
- class PVScalarArray;
- class PVBooleanArray;
- class PVByteArray;
- class PVShortArray;
- class PVIntArray;
- class PVLongArray;
- class PVFloatArray;
- class PVDoubleArray;
- class PVStringArray;
+class PVScalarArray;
+class PVBooleanArray;
+class PVByteArray;
+class PVShortArray;
+class PVIntArray;
+class PVLongArray;
+class PVFloatArray;
+class PVDoubleArray;
+class PVStringArray;
- class PVStructure;
- class PVStructureArray;
+class PVStructure;
+class PVStructureArray;
- typedef std::map PVScalarMap;
- typedef PVScalarMap::const_iterator PVScalarMapIter;
- typedef PVStructure * PVStructurePtr;
- typedef PVStructurePtr* PVStructurePtrArray;
- typedef PVField* PVFieldPtr;
- typedef PVFieldPtr * PVFieldPtrArray;
- typedef bool * BooleanArray;
- typedef int8 * ByteArray;
- typedef int16 * ShortArray;
- typedef int32 * IntArray;
- typedef int64 * LongArray;
- typedef float * FloatArray;
- typedef double * DoubleArray;
- typedef String * StringArray;
+typedef std::map PVScalarMap;
+typedef PVScalarMap::const_iterator PVScalarMapIter;
+typedef PVStructure * PVStructurePtr;
+typedef PVStructurePtr* PVStructurePtrArray;
+typedef PVField* PVFieldPtr;
+typedef PVFieldPtr * PVFieldPtrArray;
+typedef bool * BooleanArray;
+typedef int8 * ByteArray;
+typedef int16 * ShortArray;
+typedef int32 * IntArray;
+typedef int64 * LongArray;
+typedef float * FloatArray;
+typedef double * DoubleArray;
+//typedef String * StringArray; alreadt defined in pvType.h
- class PVAuxInfo : private NoDefaultMethods {
- public:
- PVAuxInfo(PVField *pvField);
- ~PVAuxInfo();
- static ConstructDestructCallback *getConstructDestructCallback();
- PVField * getPVField();
- PVScalar * createInfo(String key,ScalarType scalarType);
- PVScalarMap getInfos();
- PVScalar * getInfo(String key);
- void toString(StringBuilder buf);
- void toString(StringBuilder buf,int indentLevel);
- private:
- class PVAuxInfoPvt *pImpl;
- friend class PVDataCreate;
- };
+class PVAuxInfo : private NoDefaultMethods {
+public:
+ PVAuxInfo(PVField *pvField);
+ ~PVAuxInfo();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ PVField * getPVField();
+ PVScalar * createInfo(String key,ScalarType scalarType);
+ PVScalarMap getInfos();
+ PVScalar * getInfo(String key);
+ void toString(StringBuilder buf);
+ void toString(StringBuilder buf,int indentLevel);
+private:
+ class PVAuxInfoPvt *pImpl;
+ friend class PVDataCreate;
+};
- class PostHandler {
- public:
- virtual void postPut() = 0;
- };
+class PostHandler {
+public:
+ virtual void postPut() = 0;
+};
- class PVField
- : public Requester,
- public Serializable,
- private NoDefaultMethods
- {
- public:
- virtual ~PVField();
- static ConstructDestructCallback *getConstructDestructCallback();
- String getRequesterName() ;
- virtual void message(String message,MessageType messageType) ;
- virtual void setRequester(Requester *prequester);
- int getFieldOffset() ;
- int getNextFieldOffset() ;
- int getNumberFields() ;
- PVAuxInfo * getPVAuxInfo();
- bool isImmutable() ;
- void setImmutable();
- FieldConstPtr getField() ;
- PVStructure * getParent() ;
- void replacePVField(PVField * newPVField);
- void renameField(String newName);
- void postPut() ;
- void setPostHandler(PostHandler *postHandler);
- virtual void toString(StringBuilder buf) ;
- virtual void toString(StringBuilder buf,int indentLevel) ;
- virtual bool operator==(PVField &pv) = 0;
- virtual bool operator!=(PVField &pv) = 0;
- protected:
- PVField(PVStructure *parent,FieldConstPtr field);
- void replaceStructure(PVStructure *pvStructure);
- private:
- class PVFieldPvt *pImpl;
- static void computeOffset(PVField *pvField);
- static void computeOffset(PVField *pvField,int offset);
- friend class PVDataCreate;
- };
+class PVField
+: public Requester,
+ public Serializable,
+ private NoDefaultMethods
+{
+public:
+ virtual ~PVField();
+ static ConstructDestructCallback *getConstructDestructCallback();
+ String getRequesterName() ;
+ virtual void message(String message,MessageType messageType) ;
+ virtual void setRequester(Requester *prequester);
+ int getFieldOffset() ;
+ int getNextFieldOffset() ;
+ int getNumberFields() ;
+ PVAuxInfo * getPVAuxInfo();
+ bool isImmutable() ;
+ void setImmutable();
+ FieldConstPtr getField() ;
+ PVStructure * getParent() ;
+ void replacePVField(PVField * newPVField);
+ void renameField(String newName);
+ void postPut() ;
+ void setPostHandler(PostHandler *postHandler);
+ virtual void toString(StringBuilder buf) ;
+ virtual void toString(StringBuilder buf,int indentLevel) ;
+ virtual bool operator==(PVField &pv) = 0;
+ virtual bool operator!=(PVField &pv) = 0;
+protected:
+ PVField(PVStructure *parent,FieldConstPtr field);
+ void replaceStructure(PVStructure *pvStructure);
+private:
+ class PVFieldPvt *pImpl;
+ static void computeOffset(PVField *pvField);
+ static void computeOffset(PVField *pvField,int offset);
+ friend class PVDataCreate;
+};
- class PVScalar : public PVField {
- public:
- virtual ~PVScalar();
- ScalarConstPtr getScalar() ;
- protected:
- PVScalar(PVStructure *parent,ScalarConstPtr scalar);
- };
+class PVScalar : public PVField {
+public:
+ virtual ~PVScalar();
+ ScalarConstPtr getScalar() ;
+protected:
+ PVScalar(PVStructure *parent,ScalarConstPtr scalar);
+};
- class PVArray : public PVField, public SerializableArray {
- public:
- virtual ~PVArray();
- int getLength() ;
- void setLength(int length);
- int getCapacity() ;
- bool isCapacityMutable() ;
- void setCapacityMutable(bool isMutable);
- virtual void setCapacity(int capacity) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,
- DeserializableControl *pflusher) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher, int offset, int count) = 0;
- protected:
- PVArray(PVStructure *parent,FieldConstPtr field);
- void setCapacityLength(int capacity,int length);
- private:
- class PVArrayPvt * pImpl;
- };
+class PVArray : public PVField, public SerializableArray {
+public:
+ virtual ~PVArray();
+ int getLength() ;
+ void setLength(int length);
+ int getCapacity() ;
+ bool isCapacityMutable() ;
+ void setCapacityMutable(bool isMutable);
+ virtual void setCapacity(int capacity) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVArray(PVStructure *parent,FieldConstPtr field);
+ void setCapacityLength(int capacity,int length);
+private:
+ class PVArrayPvt * pImpl;
+};
- class PVScalarArray : public PVArray {
- public:
- virtual ~PVScalarArray();
- ScalarArrayConstPtr getScalarArray() ;
- virtual void setCapacity(int capacity) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,
- DeserializableControl *pflusher) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher, int offset, int count) = 0;
- protected:
- PVScalarArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
- private:
- };
+class PVScalarArray : public PVArray {
+public:
+ virtual ~PVScalarArray();
+ ScalarArrayConstPtr getScalarArray() ;
+ virtual void setCapacity(int capacity) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVScalarArray(PVStructure *parent,ScalarArrayConstPtr scalarArray);
+private:
+};
- class StructureArrayData {
- public:
- PVStructurePtrArray data;
- int offset;
- };
+class StructureArrayData {
+public:
+ PVStructurePtrArray data;
+ int offset;
+};
- class PVStructureArray : public PVArray {
- public:
- virtual ~PVStructureArray();
- virtual StructureArrayConstPtr getStructureArray() = 0;
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length,
- StructureArrayData *data) = 0;
- virtual int put(int offset,int length,
- PVStructurePtrArray from, int fromOffset) = 0;
- virtual void shareData( PVStructurePtrArray value,int capacity,int length) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher) = 0 ;
- virtual void deserialize(ByteBuffer *buffer,
- DeserializableControl *pflusher) = 0;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher, int offset, int count) = 0;
- protected:
- PVStructureArray(PVStructure *parent,
- StructureArrayConstPtr structureArray);
- private:
- };
-
-
- class PVStructure : public PVField,public BitSetSerializable {
- public:
- virtual ~PVStructure();
- StructureConstPtr getStructure();
- PVFieldPtrArray getPVFields();
- PVField *getSubField(String fieldName);
- PVField *getSubField(int fieldOffset);
- void appendPVField(PVField *pvField);
- void appendPVFields(int numberFields,PVFieldPtrArray pvFields);
- void removePVField(String fieldName);
- PVBoolean *getBooleanField(String fieldName);
- PVByte *getByteField(String fieldName);
- PVShort *getShortField(String fieldName);
- PVInt *getIntField(String fieldName);
- PVLong *getLongField(String fieldName);
- PVFloat *getFloatField(String fieldName);
- PVDouble *getDoubleField(String fieldName);
- PVString *getStringField(String fieldName);
- PVStructure *getStructureField(String fieldName);
- PVScalarArray *getScalarArrayField(
- String fieldName,ScalarType elementType);
- PVStructureArray *getStructureArrayField(String fieldName);
- String getExtendsStructureName();
- bool putExtendsStructureName(
- String extendsStructureName);
- virtual bool operator==(PVField &pv) ;
- virtual bool operator!=(PVField &pv) ;
- virtual void serialize(
- ByteBuffer *pbuffer,SerializableControl *pflusher) ;
- virtual void deserialize(
- ByteBuffer *pbuffer,DeserializableControl *pflusher);
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher, int offset, int count) ;
- virtual void serialize(ByteBuffer *pbuffer,
- SerializableControl *pflusher,BitSet *pbitSet) ;
- virtual void deserialize(ByteBuffer *pbuffer,
- DeserializableControl*pflusher,BitSet *pbitSet);
- protected:
- PVStructure(PVStructure *parent,StructureConstPtr structure);
- private:
- class PVStructurePvt * pImpl;
- };
-
- class PVBoolean : public PVScalar {
- public:
- virtual ~PVBoolean();
- virtual bool get() = 0;
- virtual void put(bool value) = 0;
- protected:
- PVBoolean(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVByte : public PVScalar {
- public:
- virtual ~PVByte();
- virtual int8 get() = 0;
- virtual void put(int8 value) = 0;
- protected:
- PVByte(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVShort : public PVScalar {
- public:
- virtual ~PVShort();
- virtual int16 get() = 0;
- virtual void put(int16 value) = 0;
- protected:
- PVShort(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVInt : public PVScalar{
- public:
- virtual ~PVInt();
- virtual int32 get() = 0;
- virtual void put(int32 value) = 0;
- protected:
- PVInt(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVLong : public PVScalar {
- public:
- virtual ~PVLong();
- virtual int64 get() = 0;
- virtual void put(int64 value) = 0;
- protected:
- PVLong(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVFloat : public PVScalar {
- public:
- virtual ~PVFloat();
- virtual float get() = 0;
- virtual void put(float value) = 0;
- protected:
- PVFloat(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVDouble : public PVScalar {
- public:
- virtual ~PVDouble();
- virtual double get() = 0;
- virtual void put(double value) = 0;
- protected:
- PVDouble(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class PVString : public PVScalar {
- public:
- virtual ~PVString();
- virtual String get() = 0;
- virtual void put(String value) = 0;
- protected:
- PVString(PVStructure *parent,ScalarConstPtr scalar)
- : PVScalar(parent,scalar) {}
- private:
- };
-
- class BooleanArrayData {
- public:
- BooleanArray data;
- int offset;
- };
-
- class PVBooleanArray : public PVScalarArray {
- public:
- virtual ~PVBooleanArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, BooleanArrayData *data) = 0;
- virtual int put(int offset,int length, BooleanArray from, int fromOffset) = 0;
- virtual void shareData(BooleanArray value,int capacity,int length) = 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
- protected:
- PVBooleanArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVStructureArray : public PVArray {
+public:
+ virtual ~PVStructureArray();
+ virtual StructureArrayConstPtr getStructureArray() = 0;
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length,
+ StructureArrayData *data) = 0;
+ virtual int put(int offset,int length,
+ PVStructurePtrArray from, int fromOffset) = 0;
+ virtual void shareData( PVStructurePtrArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher) = 0 ;
+ virtual void deserialize(ByteBuffer *buffer,
+ DeserializableControl *pflusher) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) = 0;
+protected:
+ PVStructureArray(PVStructure *parent,
+ StructureArrayConstPtr structureArray);
+private:
+};
- class ByteArrayData {
- public:
- ByteArray data;
- int offset;
- };
+class PVStructure : public PVField,public BitSetSerializable {
+public:
+ virtual ~PVStructure();
+ StructureConstPtr getStructure();
+ PVFieldPtrArray getPVFields();
+ PVField *getSubField(String fieldName);
+ PVField *getSubField(int fieldOffset);
+ void appendPVField(PVField *pvField);
+ void appendPVFields(int numberFields,PVFieldPtrArray pvFields);
+ void removePVField(String fieldName);
+ PVBoolean *getBooleanField(String fieldName);
+ PVByte *getByteField(String fieldName);
+ PVShort *getShortField(String fieldName);
+ PVInt *getIntField(String fieldName);
+ PVLong *getLongField(String fieldName);
+ PVFloat *getFloatField(String fieldName);
+ PVDouble *getDoubleField(String fieldName);
+ PVString *getStringField(String fieldName);
+ PVStructure *getStructureField(String fieldName);
+ PVScalarArray *getScalarArrayField(
+ String fieldName,ScalarType elementType);
+ PVStructureArray *getStructureArrayField(String fieldName);
+ String getExtendsStructureName();
+ bool putExtendsStructureName(
+ String extendsStructureName);
+ virtual bool operator==(PVField &pv) ;
+ virtual bool operator!=(PVField &pv) ;
+ virtual void serialize(
+ ByteBuffer *pbuffer,SerializableControl *pflusher) ;
+ virtual void deserialize(
+ ByteBuffer *pbuffer,DeserializableControl *pflusher);
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher, int offset, int count) ;
+ virtual void serialize(ByteBuffer *pbuffer,
+ SerializableControl *pflusher,BitSet *pbitSet) ;
+ virtual void deserialize(ByteBuffer *pbuffer,
+ DeserializableControl*pflusher,BitSet *pbitSet);
+protected:
+ PVStructure(PVStructure *parent,StructureConstPtr structure);
+private:
+ class PVStructurePvt * pImpl;
+};
- class PVByteArray : public PVScalarArray {
- public:
- virtual ~PVByteArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, ByteArrayData *data) = 0;
- virtual int put(int offset,int length, ByteArray from, int fromOffset) = 0;
- virtual void shareData(ByteArray value,int capacity,int length) = 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
- protected:
- PVByteArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVBoolean : public PVScalar {
+public:
+ virtual ~PVBoolean();
+ virtual bool get() = 0;
+ virtual void put(bool value) = 0;
+protected:
+ PVBoolean(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class ShortArrayData {
- public:
- ShortArray data;
- int offset;
- };
+class PVByte : public PVScalar {
+public:
+ virtual ~PVByte();
+ virtual int8 get() = 0;
+ virtual void put(int8 value) = 0;
+protected:
+ PVByte(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class PVShortArray : public PVScalarArray {
- public:
- virtual ~PVShortArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, ShortArrayData *data) = 0;
- virtual int put(int offset,int length, ShortArray from, int fromOffset) = 0;
- virtual void shareData(ShortArray value,int capacity,int length) = 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
- protected:
- PVShortArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVShort : public PVScalar {
+public:
+ virtual ~PVShort();
+ virtual int16 get() = 0;
+ virtual void put(int16 value) = 0;
+protected:
+ PVShort(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class IntArrayData {
- public:
- IntArray data;
- int offset;
- };
+class PVInt : public PVScalar{
+public:
+ virtual ~PVInt();
+ virtual int32 get() = 0;
+ virtual void put(int32 value) = 0;
+protected:
+ PVInt(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class PVIntArray : public PVScalarArray {
- public:
- virtual ~PVIntArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, IntArrayData *data) = 0;
- virtual int put(int offset,int length, IntArray from, int fromOffset)= 0;
- virtual void shareData(IntArray value,int capacity,int length)= 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
- protected:
- PVIntArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVLong : public PVScalar {
+public:
+ virtual ~PVLong();
+ virtual int64 get() = 0;
+ virtual void put(int64 value) = 0;
+protected:
+ PVLong(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class LongArrayData {
- public:
- LongArray data;
- int offset;
- };
+class PVFloat : public PVScalar {
+public:
+ virtual ~PVFloat();
+ virtual float get() = 0;
+ virtual void put(float value) = 0;
+protected:
+ PVFloat(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
- class PVLongArray : public PVScalarArray {
- public:
- virtual ~PVLongArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, LongArrayData *data) = 0;
- virtual int put(int offset,int length, LongArray from, int fromOffset)= 0;
- virtual void shareData(LongArray value,int capacity,int length)= 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
- protected:
- PVLongArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVDouble : public PVScalar {
+public:
+ virtual ~PVDouble();
+ virtual double get() = 0;
+ virtual void put(double value) = 0;
+protected:
+ PVDouble(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class PVString : public PVScalar {
+public:
+ virtual ~PVString();
+ virtual String get() = 0;
+ virtual void put(String value) = 0;
+protected:
+ PVString(PVStructure *parent,ScalarConstPtr scalar)
+ : PVScalar(parent,scalar) {}
+private:
+};
+
+class BooleanArrayData {
+public:
+ BooleanArray data;
+ int offset;
+};
+
+class PVBooleanArray : public PVScalarArray {
+public:
+ virtual ~PVBooleanArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, BooleanArrayData *data) = 0;
+ virtual int put(int offset,int length, BooleanArray from, int fromOffset) = 0;
+ virtual void shareData(BooleanArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVBooleanArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
- class FloatArrayData {
- public:
- FloatArray data;
- int offset;
- };
+class ByteArrayData {
+public:
+ ByteArray data;
+ int offset;
+};
- class PVFloatArray : public PVScalarArray {
- public:
- virtual ~PVFloatArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, FloatArrayData *data) = 0;
- virtual int put(int offset,int length, FloatArray from, int fromOffset)= 0;
- virtual void shareData(FloatArray value,int capacity,int length)= 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
- protected:
- PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVByteArray : public PVScalarArray {
+public:
+ virtual ~PVByteArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, ByteArrayData *data) = 0;
+ virtual int put(int offset,int length, ByteArray from, int fromOffset) = 0;
+ virtual void shareData(ByteArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVByteArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class ShortArrayData {
+public:
+ ShortArray data;
+ int offset;
+};
+
+class PVShortArray : public PVScalarArray {
+public:
+ virtual ~PVShortArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, ShortArrayData *data) = 0;
+ virtual int put(int offset,int length, ShortArray from, int fromOffset) = 0;
+ virtual void shareData(ShortArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVShortArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class IntArrayData {
+public:
+ IntArray data;
+ int offset;
+};
+
+class PVIntArray : public PVScalarArray {
+public:
+ virtual ~PVIntArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, IntArrayData *data) = 0;
+ virtual int put(int offset,int length, IntArray from, int fromOffset)= 0;
+ virtual void shareData(IntArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVIntArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class LongArrayData {
+public:
+ LongArray data;
+ int offset;
+};
+
+class PVLongArray : public PVScalarArray {
+public:
+ virtual ~PVLongArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, LongArrayData *data) = 0;
+ virtual int put(int offset,int length, LongArray from, int fromOffset)= 0;
+ virtual void shareData(LongArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVLongArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
- class DoubleArrayData {
- public:
- DoubleArrayData(){}
- ~DoubleArrayData(){};
- DoubleArray data;
- int offset;
- };
+class FloatArrayData {
+public:
+ FloatArray data;
+ int offset;
+};
- class PVDoubleArray : public PVScalarArray {
- public:
- virtual ~PVDoubleArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, DoubleArrayData *data) = 0;
- virtual int put(int offset,int length, DoubleArray from, int fromOffset) = 0;
- virtual void shareData(DoubleArray value,int capacity,int length) = 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
- protected:
- PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVFloatArray : public PVScalarArray {
+public:
+ virtual ~PVFloatArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, FloatArrayData *data) = 0;
+ virtual int put(int offset,int length, FloatArray from, int fromOffset)= 0;
+ virtual void shareData(FloatArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVFloatArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
- class StringArrayData {
- public:
- StringArray data;
- int offset;
- };
+class DoubleArrayData {
+public:
+ DoubleArrayData(){}
+ ~DoubleArrayData(){};
+ DoubleArray data;
+ int offset;
+};
- class PVStringArray : public PVScalarArray {
- public:
- virtual ~PVStringArray();
- virtual void setCapacity(int capacity) = 0;
- virtual int get(int offset, int length, StringArrayData *data) = 0;
- virtual int put(int offset,int length, StringArray from, int fromOffset)= 0;
- virtual void shareData(StringArray value,int capacity,int length)= 0;
- virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
- virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
- protected:
- PVStringArray(PVStructure *parent,ScalarArrayConstPtr scalar);
- private:
- };
+class PVDoubleArray : public PVScalarArray {
+public:
+ virtual ~PVDoubleArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, DoubleArrayData *data) = 0;
+ virtual int put(int offset,int length, DoubleArray from, int fromOffset) = 0;
+ virtual void shareData(DoubleArray value,int capacity,int length) = 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher) = 0;
+protected:
+ PVDoubleArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
- class PVDataCreate {
- public:
- PVField *createPVField(PVStructure *parent,
- FieldConstPtr field);
- PVField *createPVField(PVStructure *parent,
- String fieldName,PVField * fieldToClone);
- PVScalar *createPVScalar(PVStructure *parent,ScalarConstPtr scalar);
- PVScalar *createPVScalar(PVStructure *parent,
- String fieldName,ScalarType scalarType);
- PVScalar *createPVScalar(PVStructure *parent,
- String fieldName,PVScalar * scalarToClone);
- PVScalarArray *createPVScalarArray(PVStructure *parent,
- ScalarArrayConstPtr scalarArray);
- PVScalarArray *createPVScalarArray(PVStructure *parent,
- String fieldName,ScalarType elementType);
- PVScalarArray *createPVScalarArray(PVStructure *parent,
- String fieldName,PVScalarArray * scalarArrayToClone);
- PVStructureArray *createPVStructureArray(PVStructure *parent,
- StructureArrayConstPtr structureArray);
- PVStructure *createPVStructure(PVStructure *parent,
- StructureConstPtr structure);
- PVStructure *createPVStructure(PVStructure *parent,
- String fieldName,int numberFields,FieldConstPtrArray fields);
- PVStructure *createPVStructure(PVStructure *parent,
- String fieldName,PVStructure *structToClone);
- protected:
- PVDataCreate();
- friend PVDataCreate * getPVDataCreate();
- };
- extern PVDataCreate * getPVDataCreate();
+class StringArrayData {
+public:
+ StringArray data;
+ int offset;
+};
+
+class PVStringArray : public PVScalarArray {
+public:
+ virtual ~PVStringArray();
+ virtual void setCapacity(int capacity) = 0;
+ virtual int get(int offset, int length, StringArrayData *data) = 0;
+ virtual int put(int offset,int length, StringArray from, int fromOffset)= 0;
+ virtual void shareData(StringArray value,int capacity,int length)= 0;
+ virtual void serialize(ByteBuffer *pbuffer,SerializableControl *pflusher) = 0;
+ virtual void deserialize(ByteBuffer *pbuffer,DeserializableControl *pflusher)= 0;
+protected:
+ PVStringArray(PVStructure *parent,ScalarArrayConstPtr scalar);
+private:
+};
+
+class PVDataCreate {
+public:
+ PVField *createPVField(PVStructure *parent,
+ FieldConstPtr field);
+ PVField *createPVField(PVStructure *parent,
+ String fieldName,PVField * fieldToClone);
+ PVScalar *createPVScalar(PVStructure *parent,ScalarConstPtr scalar);
+ PVScalar *createPVScalar(PVStructure *parent,
+ String fieldName,ScalarType scalarType);
+ PVScalar *createPVScalar(PVStructure *parent,
+ String fieldName,PVScalar * scalarToClone);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ ScalarArrayConstPtr scalarArray);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType);
+ PVScalarArray *createPVScalarArray(PVStructure *parent,
+ String fieldName,PVScalarArray * scalarArrayToClone);
+ PVStructureArray *createPVStructureArray(PVStructure *parent,
+ StructureArrayConstPtr structureArray);
+ PVStructure *createPVStructure(PVStructure *parent,
+ StructureConstPtr structure);
+ PVStructure *createPVStructure(PVStructure *parent,
+ String fieldName,int numberFields,FieldConstPtrArray fields);
+ PVStructure *createPVStructure(PVStructure *parent,
+ String fieldName,PVStructure *structToClone);
+protected:
+ PVDataCreate();
+ friend PVDataCreate * getPVDataCreate();
+};
+
+extern PVDataCreate * getPVDataCreate();
}}
#endif /* PVDATA_H */
diff --git a/pvDataApp/pv/pvIntrospect.h b/pvDataApp/pv/pvIntrospect.h
index 9bb6ab5..1d7902e 100644
--- a/pvDataApp/pv/pvIntrospect.h
+++ b/pvDataApp/pv/pvIntrospect.h
@@ -13,137 +13,137 @@
#include "showConstructDestruct.h"
namespace epics { namespace pvData {
- class Field;
- class Scalar;
- class ScalarArray;
- class Structure;
- class StructureArray;
+class Field;
+class Scalar;
+class ScalarArray;
+class Structure;
+class StructureArray;
- typedef Field const * FieldConstPtr;
- typedef FieldConstPtr * FieldConstPtrArray;
- typedef Scalar const * ScalarConstPtr;
- typedef ScalarArray const * ScalarArrayConstPtr;
- typedef Structure const * StructureConstPtr;
- typedef StructureArray const * StructureArrayConstPtr;
+typedef Field const * FieldConstPtr;
+typedef FieldConstPtr * FieldConstPtrArray;
+typedef Scalar const * ScalarConstPtr;
+typedef ScalarArray const * ScalarArrayConstPtr;
+typedef Structure const * StructureConstPtr;
+typedef StructureArray const * StructureArrayConstPtr;
- enum Type {
- scalar,
- scalarArray,
- structure,
- structureArray
- };
+enum Type {
+ scalar,
+ scalarArray,
+ structure,
+ structureArray
+};
- class TypeFunc {
- public:
- static void toString(StringBuilder buf,const Type type);
- };
+class TypeFunc {
+public:
+ static void toString(StringBuilder buf,const Type type);
+};
- enum ScalarType {
- pvBoolean,
- pvByte,
- pvShort,
- pvInt,
- pvLong,
- pvFloat,
- pvDouble,
- pvString
- };
+enum ScalarType {
+ pvBoolean,
+ pvByte,
+ pvShort,
+ pvInt,
+ pvLong,
+ pvFloat,
+ pvDouble,
+ pvString
+};
- class ScalarTypeFunc {
- public:
- static bool isInteger(ScalarType type);
- static bool isNumeric(ScalarType type);
- static bool isPrimitive(ScalarType type);
- static ScalarType getScalarType(String value);
- static void toString(StringBuilder buf,ScalarType scalarType);
- };
+class ScalarTypeFunc {
+public:
+ static bool isInteger(ScalarType type);
+ static bool isNumeric(ScalarType type);
+ static bool isPrimitive(ScalarType type);
+ static ScalarType getScalarType(String value);
+ static void toString(StringBuilder buf,ScalarType scalarType);
+};
- class Field : private NoDefaultMethods {
- public:
- virtual ~Field();
- Field(String fieldName,Type type);
- static ConstructDestructCallback *getConstructDestructCallback();
- int getReferenceCount() const;
- String getFieldName() const;
- Type getType() const;
- virtual void toString(StringBuilder buf) const{toString(buf,0);}
- virtual void toString(StringBuilder buf,int indentLevel) const;
- private:
- class FieldPvt *pImpl;
- void incReferenceCount() const;
- void decReferenceCount() const;
- friend class StructureArray;
- friend class Structure;
- friend class PVFieldPvt;
- friend class StandardField;
- friend class BasePVStructureArray;
- };
+class Field : private NoDefaultMethods {
+public:
+ virtual ~Field();
+ Field(String fieldName,Type type);
+ static ConstructDestructCallback *getConstructDestructCallback();
+ int getReferenceCount() const;
+ String getFieldName() const;
+ Type getType() const;
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+ class FieldPvt *pImpl;
+ void incReferenceCount() const;
+ void decReferenceCount() const;
+ friend class StructureArray;
+ friend class Structure;
+ friend class PVFieldPvt;
+ friend class StandardField;
+ friend class BasePVStructureArray;
+};
- class Scalar : public Field{
- public:
- Scalar(String fieldName,ScalarType scalarType);
- virtual ~Scalar();
- ScalarType getScalarType() const {return scalarType;}
- virtual void toString(StringBuilder buf) const{toString(buf,0);}
- virtual void toString(StringBuilder buf,int indentLevel) const;
- private:
- ScalarType scalarType;
- };
+class Scalar : public Field{
+public:
+ Scalar(String fieldName,ScalarType scalarType);
+ virtual ~Scalar();
+ ScalarType getScalarType() const {return scalarType;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+ ScalarType scalarType;
+};
- class ScalarArray : public Field{
- public:
- ScalarArray(String fieldName,ScalarType scalarType);
- virtual ~ScalarArray();
- ScalarType getElementType() const {return elementType;}
- virtual void toString(StringBuilder buf) const{toString(buf,0);}
- virtual void toString(StringBuilder buf,int indentLevel) const;
- private:
- ScalarType elementType;
- };
+class ScalarArray : public Field{
+public:
+ ScalarArray(String fieldName,ScalarType scalarType);
+ virtual ~ScalarArray();
+ ScalarType getElementType() const {return elementType;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+ ScalarType elementType;
+};
- class StructureArray : public Field{
- public:
- StructureArray(String fieldName,StructureConstPtr structure);
- virtual ~StructureArray();
- StructureConstPtr getStructure() const {return pstructure;}
- virtual void toString(StringBuilder buf) const{toString(buf,0);}
- virtual void toString(StringBuilder buf,int indentLevel) const;
- private:
- StructureConstPtr pstructure;
- };
+class StructureArray : public Field{
+public:
+ StructureArray(String fieldName,StructureConstPtr structure);
+ virtual ~StructureArray();
+ StructureConstPtr getStructure() const {return pstructure;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+ StructureConstPtr pstructure;
+};
- class Structure : public Field {
- public:
- Structure(String fieldName, int numberFields,FieldConstPtrArray fields);
- virtual ~Structure();
- int getNumberFields() const {return numberFields;}
- FieldConstPtr getField(String fieldName) const;
- int getFieldIndex(String fieldName) const;
- FieldConstPtrArray getFields() const {return fields;}
- virtual void toString(StringBuilder buf) const{toString(buf,0);}
- virtual void toString(StringBuilder buf,int indentLevel) const;
- private:
- int numberFields;
- FieldConstPtrArray fields;
- };
+class Structure : public Field {
+public:
+ Structure(String fieldName, int numberFields,FieldConstPtrArray fields);
+ virtual ~Structure();
+ int getNumberFields() const {return numberFields;}
+ FieldConstPtr getField(String fieldName) const;
+ int getFieldIndex(String fieldName) const;
+ FieldConstPtrArray getFields() const {return fields;}
+ virtual void toString(StringBuilder buf) const{toString(buf,0);}
+ virtual void toString(StringBuilder buf,int indentLevel) const;
+private:
+ int numberFields;
+ FieldConstPtrArray fields;
+};
- class FieldCreate : NoDefaultMethods {
- public:
- FieldConstPtr create(String fieldName,FieldConstPtr field) const;
- ScalarConstPtr createScalar(String fieldName,ScalarType scalarType) const;
- ScalarArrayConstPtr createScalarArray(String fieldName,
- ScalarType elementType) const;
- StructureConstPtr createStructure (String fieldName,
- int numberFields,FieldConstPtrArray fields) const;
- StructureArrayConstPtr createStructureArray(String fieldName,
- StructureConstPtr structure) const;
- private:
- FieldCreate();
- friend FieldCreate * getFieldCreate();
- };
+class FieldCreate : NoDefaultMethods {
+public:
+ FieldConstPtr create(String fieldName,FieldConstPtr field) const;
+ ScalarConstPtr createScalar(String fieldName,ScalarType scalarType) const;
+ ScalarArrayConstPtr createScalarArray(String fieldName,
+ ScalarType elementType) const;
+ StructureConstPtr createStructure (String fieldName,
+ int numberFields,FieldConstPtrArray fields) const;
+ StructureArrayConstPtr createStructureArray(String fieldName,
+ StructureConstPtr structure) const;
+private:
+ FieldCreate();
+ friend FieldCreate * getFieldCreate();
+};
- extern FieldCreate * getFieldCreate();
+extern FieldCreate * getFieldCreate();
}}
#endif /* PVINTROSPECT_H */
diff --git a/pvDataApp/pv/standardField.h b/pvDataApp/pv/standardField.h
index fdcc9ce..0c7e709 100644
--- a/pvDataApp/pv/standardField.h
+++ b/pvDataApp/pv/standardField.h
@@ -12,57 +12,57 @@
namespace epics { namespace pvData {
- class StandardField : private NoDefaultMethods {
- public:
- StandardField();
- ~StandardField();
- ScalarConstPtr scalar(String fieldName,ScalarType type);
- StructureConstPtr scalar(String fieldName,
- ScalarType type,String properties);
- ScalarArrayConstPtr scalarArray(String fieldName,
- ScalarType elementType);
- StructureConstPtr scalarArray(String fieldName,
- ScalarType elementType, String properties);
- StructureArrayConstPtr structureArray(String fieldName,
- StructureConstPtr structure);
- StructureConstPtr structureArray(String fieldName,
- StructureConstPtr structure,String properties);
- StructureConstPtr structure(String fieldName,
- int numFields,FieldConstPtrArray fields);
- StructureConstPtr enumerated(String fieldName,
- StringArray choices);
- StructureConstPtr enumerated(String fieldName,
- StringArray choices, String properties);
- ScalarConstPtr scalarValue(ScalarType type);
- StructureConstPtr scalarValue(ScalarType type,String properties);
- ScalarArrayConstPtr scalarArrayValue(ScalarType elementType);
- StructureConstPtr scalarArrayValue(ScalarType elementType,
- String properties);
- StructureArrayConstPtr structureArrayValue(StructureConstPtr structure);
- StructureConstPtr structureArrayValue(StructureConstPtr structure,
- String properties);
- StructureConstPtr structureValue(
- int numFields,FieldConstPtrArray fields);
- StructureConstPtr enumeratedValue(StringArray choices);
- StructureConstPtr enumeratedValue(StringArray choices,
- String properties);
- StructureConstPtr alarm();
- StructureConstPtr timeStamp();
- StructureConstPtr display();
- StructureConstPtr control();
- StructureConstPtr booleanAlarm();
- StructureConstPtr byteAlarm();
- StructureConstPtr shortAlarm();
- StructureConstPtr intAlarm();
- StructureConstPtr longAlarm();
- StructureConstPtr floatAlarm();
- StructureConstPtr doubleAlarm();
- StructureConstPtr enumeratedAlarm();
- private:
- static void init();
- };
+class StandardField : private NoDefaultMethods {
+public:
+ StandardField();
+ ~StandardField();
+ ScalarConstPtr scalar(String fieldName,ScalarType type);
+ StructureConstPtr scalar(String fieldName,
+ ScalarType type,String properties);
+ ScalarArrayConstPtr scalarArray(String fieldName,
+ ScalarType elementType);
+ StructureConstPtr scalarArray(String fieldName,
+ ScalarType elementType, String properties);
+ StructureArrayConstPtr structureArray(String fieldName,
+ StructureConstPtr structure);
+ StructureConstPtr structureArray(String fieldName,
+ StructureConstPtr structure,String properties);
+ StructureConstPtr structure(String fieldName,
+ int numFields,FieldConstPtrArray fields);
+ StructureConstPtr enumerated(String fieldName,
+ StringArray choices);
+ StructureConstPtr enumerated(String fieldName,
+ StringArray choices, String properties);
+ ScalarConstPtr scalarValue(ScalarType type);
+ StructureConstPtr scalarValue(ScalarType type,String properties);
+ ScalarArrayConstPtr scalarArrayValue(ScalarType elementType);
+ StructureConstPtr scalarArrayValue(ScalarType elementType,
+ String properties);
+ StructureArrayConstPtr structureArrayValue(StructureConstPtr structure);
+ StructureConstPtr structureArrayValue(StructureConstPtr structure,
+ String properties);
+ StructureConstPtr structureValue(
+ int numFields,FieldConstPtrArray fields);
+ StructureConstPtr enumeratedValue(StringArray choices);
+ StructureConstPtr enumeratedValue(StringArray choices,
+ String properties);
+ StructureConstPtr alarm();
+ StructureConstPtr timeStamp();
+ StructureConstPtr display();
+ StructureConstPtr control();
+ StructureConstPtr booleanAlarm();
+ StructureConstPtr byteAlarm();
+ StructureConstPtr shortAlarm();
+ StructureConstPtr intAlarm();
+ StructureConstPtr longAlarm();
+ StructureConstPtr floatAlarm();
+ StructureConstPtr doubleAlarm();
+ StructureConstPtr enumeratedAlarm();
+private:
+ static void init();
+};
- extern StandardField * getStandardField();
+extern StandardField * getStandardField();
}}
#endif /* STANDARDFIELD_H */
diff --git a/pvDataApp/pv/standardPVField.h b/pvDataApp/pv/standardPVField.h
index be1ea74..3600e34 100644
--- a/pvDataApp/pv/standardPVField.h
+++ b/pvDataApp/pv/standardPVField.h
@@ -13,54 +13,54 @@
namespace epics { namespace pvData {
- class StandardPVField : private NoDefaultMethods {
- public:
- StandardPVField();
- ~StandardPVField();
- PVScalar * scalar(PVStructure *parent,String fieldName,ScalarType type);
- PVStructure * scalar(PVStructure *parent,
- String fieldName,ScalarType type,String properties);
- PVScalarArray * scalarArray(PVStructure *parent,
- String fieldName,ScalarType elementType);
- PVStructure * scalarArray(PVStructure *parent,
- String fieldName,ScalarType elementType, String properties);
- PVStructureArray * structureArray(PVStructure *parent,
- String fieldName,StructureConstPtr structure);
- PVStructure* structureArray(PVStructure *parent,
- String fieldName,StructureConstPtr structure,String properties);
- PVStructure * enumerated(PVStructure *parent,
- String fieldName,StringArray choices);
- PVStructure * enumerated(PVStructure *parent,
- String fieldName,StringArray choices, String properties);
- PVScalar * scalarValue(PVStructure *parent,ScalarType type);
- PVStructure * scalarValue(PVStructure *parent,
- ScalarType type,String properties);
- PVScalarArray * scalarArrayValue(PVStructure *parent,ScalarType elementType);
- PVStructure * scalarArrayValue(PVStructure *parent,
- ScalarType elementType, String properties);
- PVStructureArray * structureArrayValue(PVStructure *parent,
- StructureConstPtr structure);
- PVStructure * structureArrayValue(PVStructure *parent,
- StructureConstPtr structure,String properties);
- PVStructure * enumeratedValue(PVStructure *parent,StringArray choices);
- PVStructure * enumeratedValue(PVStructure *parent,
- StringArray choices, String properties);
- PVStructure * alarm(PVStructure *parent);
- PVStructure * timeStamp(PVStructure *parent);
- PVStructure * display(PVStructure *parent);
- PVStructure * control(PVStructure *parent);
- PVStructure * booleanAlarm(PVStructure *parent);
- PVStructure * byteAlarm(PVStructure *parent);
- PVStructure * shortAlarm(PVStructure *parent);
- PVStructure * intAlarm(PVStructure *parent);
- PVStructure * longAlarm(PVStructure *parent);
- PVStructure * floatAlarm(PVStructure *parent);
- PVStructure * doubleAlarm(PVStructure *parent);
- PVStructure * enumeratedAlarm(PVStructure *parent);
- PVStructure * powerSupply(PVStructure *parent);
- };
+class StandardPVField : private NoDefaultMethods {
+public:
+ StandardPVField();
+ ~StandardPVField();
+ PVScalar * scalar(PVStructure *parent,String fieldName,ScalarType type);
+ PVStructure * scalar(PVStructure *parent,
+ String fieldName,ScalarType type,String properties);
+ PVScalarArray * scalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType);
+ PVStructure * scalarArray(PVStructure *parent,
+ String fieldName,ScalarType elementType, String properties);
+ PVStructureArray * structureArray(PVStructure *parent,
+ String fieldName,StructureConstPtr structure);
+ PVStructure* structureArray(PVStructure *parent,
+ String fieldName,StructureConstPtr structure,String properties);
+ PVStructure * enumerated(PVStructure *parent,
+ String fieldName,StringArray choices);
+ PVStructure * enumerated(PVStructure *parent,
+ String fieldName,StringArray choices, String properties);
+ PVScalar * scalarValue(PVStructure *parent,ScalarType type);
+ PVStructure * scalarValue(PVStructure *parent,
+ ScalarType type,String properties);
+ PVScalarArray * scalarArrayValue(PVStructure *parent,ScalarType elementType);
+ PVStructure * scalarArrayValue(PVStructure *parent,
+ ScalarType elementType, String properties);
+ PVStructureArray * structureArrayValue(PVStructure *parent,
+ StructureConstPtr structure);
+ PVStructure * structureArrayValue(PVStructure *parent,
+ StructureConstPtr structure,String properties);
+ PVStructure * enumeratedValue(PVStructure *parent,StringArray choices);
+ PVStructure * enumeratedValue(PVStructure *parent,
+ StringArray choices, String properties);
+ PVStructure * alarm(PVStructure *parent);
+ PVStructure * timeStamp(PVStructure *parent);
+ PVStructure * display(PVStructure *parent);
+ PVStructure * control(PVStructure *parent);
+ PVStructure * booleanAlarm(PVStructure *parent);
+ PVStructure * byteAlarm(PVStructure *parent);
+ PVStructure * shortAlarm(PVStructure *parent);
+ PVStructure * intAlarm(PVStructure *parent);
+ PVStructure * longAlarm(PVStructure *parent);
+ PVStructure * floatAlarm(PVStructure *parent);
+ PVStructure * doubleAlarm(PVStructure *parent);
+ PVStructure * enumeratedAlarm(PVStructure *parent);
+ PVStructure * powerSupply(PVStructure *parent);
+};
- extern StandardPVField * getStandardPVField();
+extern StandardPVField * getStandardPVField();
}}
#endif /* STANDARDPVFIELD_H */
diff --git a/test/testIntrospect b/test/testIntrospect
index ae84a81..9de4a2d 100644
--- a/test/testIntrospect
+++ b/test/testIntrospect
@@ -77,5 +77,7 @@ structure value
structure timeStamp
long secondsPastEpoch
int nanoSeconds
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 156 totalDestruct 63 totalReference 93
pvField: totalConstruct 55 totalDestruct 55
diff --git a/test/testIntrospectGold b/test/testIntrospectGold
index ae84a81..9de4a2d 100644
--- a/test/testIntrospectGold
+++ b/test/testIntrospectGold
@@ -77,5 +77,7 @@ structure value
structure timeStamp
long secondsPastEpoch
int nanoSeconds
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 156 totalDestruct 63 totalReference 93
pvField: totalConstruct 55 totalDestruct 55
diff --git a/test/testLinkedListAux b/test/testLinkedListAux
index 0dbfb83..5b7cd91 100644
--- a/test/testLinkedListAux
+++ b/test/testLinkedListAux
@@ -1,20 +1,20 @@
Time test
-diff 25.093909 milliSeconds
-time per iteration 25.093909 microseconds
-time per addTail/removeHead 0.012547 microseconds
+diff 30.073240 milliSeconds
+time per iteration 30.073240 microseconds
+time per addTail/removeHead 0.015037 microseconds
Time test locked
-diff 176.854724 milliSeconds
-time per iteration 176.854724 microseconds
-time per addTail/removeHead 0.088427 microseconds
+diff 188.396252 milliSeconds
+time per iteration 188.396252 microseconds
+time per addTail/removeHead 0.094198 microseconds
-Time ArrayList test
-diff 651.776054 milliSeconds
-time per iteration 651.776054 microseconds
-time per addTail/removeHead 0.325888 microseconds
+Time std::list test
+diff 656.937507 milliSeconds
+time per iteration 656.937507 microseconds
+time per addTail/removeHead 0.328469 microseconds
-Time ArrayList test locked
-diff 808.411295 milliSeconds
-time per iteration 808.411295 microseconds
-time per addTail/removeHead 0.404206 microseconds
+Time std::list test locked
+diff 814.306906 milliSeconds
+time per iteration 814.306906 microseconds
+time per addTail/removeHead 0.407153 microseconds
diff --git a/test/testPVAuxInfo b/test/testPVAuxInfo
index 533839c..cd08a3d 100644
--- a/test/testPVAuxInfo
+++ b/test/testPVAuxInfo
@@ -33,6 +33,8 @@ units offset 11 next 12 number 1
limit offset 12 next 15 number 3
low offset 13 next 14 number 1
high offset 14 next 15 number 1
+linkedListNode: totalConstruct 6 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 111 totalDestruct 18 totalReference 93
pvField: totalConstruct 17 totalDestruct 17
pvAuxInfo: totalConstruct 1 totalDestruct 1
diff --git a/test/testPVAuxInfoGold b/test/testPVAuxInfoGold
index 533839c..cd08a3d 100644
--- a/test/testPVAuxInfoGold
+++ b/test/testPVAuxInfoGold
@@ -33,6 +33,8 @@ units offset 11 next 12 number 1
limit offset 12 next 15 number 3
low offset 13 next 14 number 1
high offset 14 next 15 number 1
+linkedListNode: totalConstruct 6 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 111 totalDestruct 18 totalReference 93
pvField: totalConstruct 17 totalDestruct 17
pvAuxInfo: totalConstruct 1 totalDestruct 1
diff --git a/test/testPVData b/test/testPVData
index ea8eb3d..895db48 100644
--- a/test/testPVData
+++ b/test/testPVData
@@ -281,5 +281,7 @@ structure string
structure timeStamp
long secondsPastEpoch 0
int nanoSeconds 0
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 388 totalDestruct 295 totalReference 93
pvField: totalConstruct 279 totalDestruct 279
diff --git a/test/testPVDataGold b/test/testPVDataGold
index ea8eb3d..895db48 100644
--- a/test/testPVDataGold
+++ b/test/testPVDataGold
@@ -281,5 +281,7 @@ structure string
structure timeStamp
long secondsPastEpoch 0
int nanoSeconds 0
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 388 totalDestruct 295 totalReference 93
pvField: totalConstruct 279 totalDestruct 279
diff --git a/test/testPVStructureArray b/test/testPVStructureArray
index 2edafb6..2312d5e 100644
--- a/test/testPVStructureArray
+++ b/test/testPVStructureArray
@@ -56,5 +56,7 @@ structure powerSupply
structure timeStamp
long secondsPastEpoch 0
int nanoSeconds 0
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 153 totalDestruct 60 totalReference 93
pvField: totalConstruct 56 totalDestruct 56
diff --git a/test/testPVStructureArrayGold b/test/testPVStructureArrayGold
index 2edafb6..2312d5e 100644
--- a/test/testPVStructureArrayGold
+++ b/test/testPVStructureArrayGold
@@ -56,5 +56,7 @@ structure powerSupply
structure timeStamp
long secondsPastEpoch 0
int nanoSeconds 0
+linkedListNode: totalConstruct 5 totalDestruct 0
+linkedList: totalConstruct 1 totalDestruct 0
field: totalConstruct 153 totalDestruct 60 totalReference 93
pvField: totalConstruct 56 totalDestruct 56
diff --git a/test/testThreadAux b/test/testThreadAux
index cc072cb..a2b64c8 100644
--- a/test/testThreadAux
+++ b/test/testThreadAux
@@ -1 +1 @@
-time per call 23.580658 microseconds
+time per call 33.872702 microseconds
diff --git a/test/testTimeStampAux b/test/testTimeStampAux
index 1204fc9..f9ffe35 100644
--- a/test/testTimeStampAux
+++ b/test/testTimeStampAux
@@ -1 +1,5 @@
-current 1290516873 809711508 milliSec 1290516873809
+current 1291321593 147449761 milliSec 1291321593147
+2010.12.02 15:26:33 147449761 nanoSeconds isDst false
+fromTime_t
+current 1291321593 0 milliSec 1291321593000
+2010.12.02 15:26:33 0 nanoSeconds isDst false
diff --git a/test/testTimer b/test/testTimer
index 33d35fa..4740546 100644
--- a/test/testTimer
+++ b/test/testTimer
@@ -1,3 +1,5 @@
+linkedListNode: totalConstruct 20 totalDestruct 12
+linkedList: totalConstruct 5 totalDestruct 3
event: totalConstruct 15 totalDestruct 15
thread: totalConstruct 3 totalDestruct 3
timerNode: totalConstruct 6 totalDestruct 6
diff --git a/test/testTimerAux b/test/testTimerAux
index 25b8865..9592f2b 100644
--- a/test/testTimerAux
+++ b/test/testTimerAux
@@ -1,6 +1,6 @@
-one requested 0.400000 diff 0.400214 seconds
-two requested 0.200000 diff 0.200183 seconds
-one requested 0.200000 diff 0.200328 seconds
-two requested 0.400000 diff 0.400277 seconds
-one requested 0.000000 diff 0.000038 seconds
-two requested 0.000000 diff 0.000060 seconds
+one requested 0.400000 diff 0.400275 seconds
+two requested 0.200000 diff 0.200137 seconds
+one requested 0.200000 diff 0.200168 seconds
+two requested 0.400000 diff 0.400172 seconds
+one requested 0.000000 diff 0.000026 seconds
+two requested 0.000000 diff 0.000082 seconds
diff --git a/test/testTimerGold b/test/testTimerGold
index 33d35fa..4740546 100644
--- a/test/testTimerGold
+++ b/test/testTimerGold
@@ -1,3 +1,5 @@
+linkedListNode: totalConstruct 20 totalDestruct 12
+linkedList: totalConstruct 5 totalDestruct 3
event: totalConstruct 15 totalDestruct 15
thread: totalConstruct 3 totalDestruct 3
timerNode: totalConstruct 6 totalDestruct 6