epics::pvData::SerializeHelper Class Reference

Serialization helper. More...

#include "serializeHelper.h"

Static Public Member Functions
static void	writeSize (std::size_t s, ByteBuffer *buffer, SerializableControl *flusher)
static std::size_t	readSize (ByteBuffer *buffer, DeserializableControl *control)
static void	serializeString (const std::string &value, ByteBuffer *buffer, SerializableControl *flusher)
static void	serializeSubstring (const std::string &value, std::size_t offset, std::size_t count, ByteBuffer *buffer, SerializableControl *flusher)
static std::string	deserializeString (ByteBuffer *buffer, DeserializableControl *control)

Detailed Description

Serialization helper.

Definition at line 29 of file serializeHelper.h.

Member Function Documentation

string epics::pvData::SerializeHelper::deserializeString ( ByteBuffer *  buffer, DeserializableControl *  control  )

static

std::string deserialization helper method. TODO This method cannot return "null", but Java implementation could have serialized "null" value as well. We need to decide how to deserialize "null".

Parameters

[in]	buffer	deserialization buffer
[in]	control	control

Returns

deserialized string

Todo:

This method cannot return "null", but Java implementation could have serialized "null" value as well. We need to decide how to deserialize "null".

Definition at line 102 of file serializeHelper.cpp.

                                                {

            std::size_t size = SerializeHelper::readSize(buffer, control);
            if(size!=(size_t)-1)    // TODO null strings check, to be removed in the future
            {
                if (buffer->getRemaining()>=size)
                {
                    // entire string is in buffer, simply create a string out of it (copy)
                    std::size_t pos = buffer->getPosition();
                    string str(buffer->getBuffer()+pos, size);
                    buffer->setPosition(pos+size);
                    return str;
                }
                else
                {
                    string str;
                    str.reserve(size);
                    try {
                        std::size_t i = 0;
                        while(true) {
                            std::size_t toRead = min(size-i, buffer->getRemaining());
                            std::size_t pos = buffer->getPosition();
                            str.append(buffer->getBuffer()+pos, toRead);
                            buffer->setPosition(pos+toRead);
                            i += toRead;
                            if(i<size)
                                control->ensureData(1); // at least one
                            else
                                break;
                        }
                        return str;
                    } catch(...) {
                        throw;
                    }
                }
            }
            else
                return std::string();
        }

std::size_t epics::pvData::SerializeHelper::readSize ( ByteBuffer *  buffer, DeserializableControl *  control  )

static

Deserialize array size. The specified DeserializableControl ensures sufficient bytes are available.

Parameters

[in]	buffer	deserialization buffer.
[in]	control	the DeserializableControl.

Returns

array size.

Definition at line 46 of file serializeHelper.cpp.

                                                {
            control->ensureData(1);
            int8 b = buffer->getByte();
            if(b==-1)
                return -1;
            else if(b==-2) {
                control->ensureData(sizeof(int32));
                int32 s = buffer->getInt();
                if(s<0) THROW_BASE_EXCEPTION("negative size");
                return s;
            }
            else
                return (std::size_t)(b<0 ? b+256 : b);
        }

void epics::pvData::SerializeHelper::serializeString ( const std::string &  value, ByteBuffer *  buffer, SerializableControl *  flusher  )

static

std::string serialization helper method.

Parameters

[in]	value	std::string to serialize
[in]	buffer	serialization buffer
[in]	flusher	flusher

Definition at line 62 of file serializeHelper.cpp.

                                                                  {
            std::size_t len = value.length();
            SerializeHelper::writeSize(len, buffer, flusher);
            if (len<=0) return;
            std::size_t i = 0;
            while(true) {
                std::size_t maxToWrite = min(len-i, buffer->getRemaining());
                buffer->put(value.data(), i, maxToWrite); // ASCII
                i += maxToWrite;
                if(i<len)
                    flusher->flushSerializeBuffer();
                else
                    break;
            }
        }

void epics::pvData::SerializeHelper::serializeSubstring ( const std::string &  value, std::size_t  offset, std::size_t  count, ByteBuffer *  buffer, SerializableControl *  flusher  )

static

std::string serialization helper method.

Parameters

[in]	value	std::string to serialize
[in]	offset	start of the substring in value
[in]	count	the number of characters to write
[in]	buffer	serialization buffer
[in]	flusher	flusher

Definition at line 79 of file serializeHelper.cpp.

                                              {
            /*if(offset<0)
                offset = 0;
            else*/ if(offset>value.length()) offset = value.length();

            if(offset+count>value.length()) count = value.length()-offset;

            SerializeHelper::writeSize(count, buffer, flusher);
            /*if (count<=0)*/ return;
            std::size_t i = 0;
            while(true) {
                std::size_t maxToWrite = min(count-i, buffer->getRemaining());
                buffer->put(value.data(), offset+i, maxToWrite); // ASCII
                i += maxToWrite;
                if(i<count)
                    flusher->flushSerializeBuffer();
                else
                    break;
            }
        }

void epics::pvData::SerializeHelper::writeSize ( std::size_t  s, ByteBuffer *  buffer, SerializableControl *  flusher  )

static

Serialize the specified array size into the specified buffer, flushing when necessary. The specified SerializableControl manages any flushing required.

Parameters

[in]	s	size to encode
[in]	buffer	serialization buffer
[in]	flusher	SerializableControl to manage the flushing

Definition at line 28 of file serializeHelper.cpp.

                                              {
            flusher->ensureBuffer(sizeof(int64)+1);
            SerializeHelper::writeSize(s, buffer);
        }

---

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

• modules/pvData/src/misc/pv/serializeHelper.h
• modules/pvData/src/misc/serializeHelper.cpp