diff options
Diffstat (limited to 'mcop/datapacket.h')
| -rw-r--r-- | mcop/datapacket.h | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/mcop/datapacket.h b/mcop/datapacket.h new file mode 100644 index 0000000..34cd211 --- /dev/null +++ b/mcop/datapacket.h @@ -0,0 +1,230 @@ + /* + + Copyright (C) 2000 Stefan Westerfeld + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with this library; see the file COPYING.LIB. If not, write to + the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. + + */ + +#ifndef DATAPACKET_H +#define DATAPACKET_H + +#include "arts_export.h" +#include "buffer.h" + +/* + * BC - Status (2002-03-08): GenericDataChannel, DataPacket types + * + * These classes must be kept binary compatible, as the do interact with + * generated code. So you MUST KNOW WHAT YOU ARE DOING, once you start + * using the provided d pointers for extensions. + */ + +namespace Arts { +class GenericDataChannelPrivate; +class GenericDataPacket; +/* + * The GenericDataChannel interface is to be implemented by the flowsystem + */ +class ARTS_EXPORT GenericDataChannel { +private: + GenericDataChannelPrivate *d; // unused + +protected: + friend class GenericDataPacket; + + /* + * this is used internally by DataPacket + */ + virtual void processedPacket(GenericDataPacket *packet) = 0; + + /* + * used internally by DataPacket + */ + virtual void sendPacket(GenericDataPacket *packet) = 0; + +public: + /* + * used to set pull delivery mode + */ + virtual void setPull(int packets, int capacity) = 0; + virtual void endPull() = 0; + + GenericDataChannel() : d(0) + { + } +}; + +/* + * DataPackets are the heard of asynchronous streaming (MCOP has synchronous + * and asynchronous streams). They are used + * + * - in the interface async streams expose to C++ implementations of MCOP + * interfaces (they directly deal with datapackets) + * + * - from the FlowSystem implemenentations + */ + +/** + * The GenericDataPacket class provides the interface the flow system can + * use to deal with data packets. + */ +class GenericDataPacketPrivate; + +class ARTS_EXPORT GenericDataPacket { +private: + GenericDataPacketPrivate *d; + static long _staticDataPacketCount; + +public: + /** + * the amount of active data packets (memory leak debugging only) + */ + static long _dataPacketCount() { return _staticDataPacketCount; } + + /** + * the channel this datapacket belongs to + */ + GenericDataChannel *channel; + + /** + * ensureCapactity ensures that there is room for at least capacity + * Elements in the packet. This is implemented destructive - that + * means: you may not find your old contents in the packet after + * calling ensureCapacity + */ + virtual void ensureCapacity(int capacity) = 0; + + /** + * read/write write the contents of the packet. Read will also + * automatically ensure that capacity is adapted before reading. + */ + virtual void read(Buffer& stream) = 0; + virtual void write(Buffer& stream) = 0; + + /** + * having size here (and not in the derived concrete DataPackets) is so + * that we can see whether the sender can't supply more data (and starts + * sending zero size packets + */ + int size; + + /** + * useCount is to be set from sendPacket + */ + int useCount; + + inline void send() + { + channel->sendPacket(this); + } + inline void processed() + { + useCount--; + if(useCount == 0) + { + if(channel) + channel->processedPacket(this); + else + delete this; + } + } + + virtual ~GenericDataPacket() + { + _staticDataPacketCount--; + } + +protected: + GenericDataPacket(GenericDataChannel *channel) + :d(0),channel(channel),useCount(0) + { + _staticDataPacketCount++; + } +}; + +/** + * The DataPacket<T> interface is what C++ implementations of MCOP interfaces + * will need to use. + */ +template<class T> +class DataPacket : public GenericDataPacket { +public: + T *contents; + +protected: + DataPacket(GenericDataChannel *channel) + : GenericDataPacket(channel) {} + ~DataPacket() {} +}; + +/** + * The RawDataPacket<T> interface handles raw class T arrays of data + */ +template<class T> +class RawDataPacket : public DataPacket<T> { +protected: + int capacity; + void ensureCapacity(int newCapacity) + { + if(newCapacity > capacity) + { + delete[] this->contents; + capacity = newCapacity; + this->contents = new T[capacity]; + } + } + RawDataPacket(int capacity, GenericDataChannel *channel) + :DataPacket<T>(channel), capacity(capacity) + { + this->size = capacity; + this->contents = new T[capacity]; + } + ~RawDataPacket() + { + delete[] this->contents; + } +}; + +/** + * FloatDataPacket finally is one concrete DataPacket (which contains the + * information how to marshal a datapacket of type float) + */ +class ARTS_EXPORT FloatDataPacket : public RawDataPacket<float> { +public: + FloatDataPacket(int capacity, GenericDataChannel *channel) + : RawDataPacket<float>(capacity, channel) + { + // + } + void read(Buffer& stream); + void write(Buffer& stream); +}; + +class ARTS_EXPORT ByteDataPacket : public RawDataPacket<mcopbyte> { +public: + ByteDataPacket(int capacity, GenericDataChannel *channel) + : RawDataPacket<mcopbyte>(capacity, channel) + { + // + } + void read(Buffer& stream); + void write(Buffer& stream); +}; + +} +#endif |