StringSerializer Class Reference

Utility class (not a tool or so) to serialize strings into stream of 32bit integers. More...

#include <StringSerializer.h>

Collaboration diagram for StringSerializer:

Public Member Functions
void	serialize (const std::vector< std::string > &strings, std::vector< uint32_t > &storage)
	Serializes vector of strings into vector of integers. More...
void	serialize (const std::string &str, std::vector< uint32_t > &storage)
std::size_t	deserialize (std::vector< uint32_t >::const_iterator first, std::vector< uint32_t >::const_iterator last, std::vector< std::string > &strings)
	Deserialize vector into strings. More...
std::size_t	deserialize (const std::vector< uint32_t > &storage, std::vector< std::string > &strings)
	Same as above but with vector instead of iterators. More...
std::vector< std::string >	deserialize (const std::vector< uint32_t > &storage)
	Same as above but return string by value (useful when invoked from Python) More...
std::size_t	deserialize (std::vector< uint32_t >::const_iterator first, std::vector< uint32_t >::const_iterator last, std::string &str)
	Deserialize one single string. More...
std::size_t	deserialize (const std::vector< uint32_t > &storage, std::string &str)
	Deserialize one single string More...
unsigned int	inquireSize (const std::vector< uint32_t > &storage)
	Return number of strings serialized into 'storage'. More...

Private Member Functions
unsigned int	getPadding (unsigned int sizeToReserve)
	Get number of padding bytes needed to align with uint32_t. More...

Private Attributes
std::ostringstream	m_ostream
	sstream used in serialization More...
std::istringstream	m_istream
	sstream used in de-serialization More...

Static Private Attributes
static const char *const	s_delimiter = "\n"
	default delimeter which is put between strings from the input vector while serialization happens More...

Detailed Description

Utility class (not a tool or so) to serialize strings into stream of 32bit integers.

Definition at line 19 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

Member Function Documentation

deserialize() [1/5]

std::vector<std::string> StringSerializer::deserialize ( const std::vector< uint32_t > &  storage )

inline

Same as above but return string by value (useful when invoked from Python)

Definition at line 54 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

                                                                        {
    std::vector<std::string> strings;
    deserialize(storage.begin(), storage.end(), strings);
    return strings;
  }

deserialize() [2/5]

std::size_t StringSerializer::deserialize ( const std::vector< uint32_t > &  storage, std::string &  str  )

inline

Deserialize one single string

Definition at line 66 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

                                                                              {
    return deserialize(storage.begin(), storage.end(), str);
  }

deserialize() [3/5]

std::size_t StringSerializer::deserialize ( const std::vector< uint32_t > &  storage, std::vector< std::string > &  strings  )

inline

Same as above but with vector instead of iterators.

Definition at line 49 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

                                                                                             {
    return deserialize(storage.begin(), storage.end(), strings);
  }

deserialize() [4/5]

std::size_t StringSerializer::deserialize	(	std::vector< uint32_t >::const_iterator	first,
		std::vector< uint32_t >::const_iterator	last,
		std::string &	str
	)

Deserialize one single string.

Definition at line 107 of file TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx.

{
  std::vector<std::string> tmp;
  std::size_t nWords = deserialize(first, last, tmp); 
  if (tmp.size() == 1 )
    str = tmp[0];
 
  return nWords;
}

deserialize() [5/5]

std::size_t StringSerializer::deserialize	(	std::vector< uint32_t >::const_iterator	first,
		std::vector< uint32_t >::const_iterator	last,
		std::vector< std::string > &	strings
	)

Deserialize vector into strings.

Parameters

first	Beginning of 'byte-stream'
last	End of 'byte-stream', i.e. vector::end()
strings	Vector of strings to hold result

Returns

Number of words consumed during deserialization

Definition at line 62 of file TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx.

{
  std::size_t storageSize = std::distance(first, last);
  
  if ( storageSize <= 1 ) return storageSize;
  unsigned int numOfStrings = *first;
 
  // Copy storage into array of uint32_t
  uint32_t * uarray = new uint32_t[storageSize-1];
  std::vector<uint32_t>::const_iterator itBegin = first; 
  advance(itBegin, 1);
  copy(itBegin, last, &uarray[0]);
 
  /*
    unsigned int i;
    std::cerr << "deserialized: " << std::endl;
    for ( i = 0 ; i < storage.size()-1; ++i ) {
    std::cerr << " " << std::hex << uarray[i] ;
    }
    std::cerr << " " << std::dec << std::endl;
  */
  
  const char * carray = (const char*)uarray;
  std::string whole(carray, (storageSize-1)*sizeof(uint32_t));
 
  m_istream.clear();  // istream reset
  m_istream.str(whole);
 
  std::string one;
  unsigned int readInStrings=0;
  std::size_t nChars=0;
  
  while ( m_istream.good() && readInStrings < numOfStrings ) {
    getline(m_istream, one, s_delimiter[0]);
    strings.push_back(one);
    readInStrings++;
    nChars += one.size() + 1;
  }
  delete[] uarray;
  
  return 1 + (nChars+getPadding(nChars))/sizeof(uint32_t);  // # uint32_t words (incl. header)
}

getPadding()

unsigned int StringSerializer::getPadding ( unsigned int  sizeToReserve )

inlineprivate

Get number of padding bytes needed to align with uint32_t.

Definition at line 80 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

                                                      {
    return (sizeof(uint32_t) - sizeToReserve%sizeof(uint32_t)) % sizeof(uint32_t);
  }

inquireSize()

unsigned int StringSerializer::inquireSize

(

const std::vector< uint32_t > &

storage

)

Return number of strings serialized into 'storage'.

Definition at line 119 of file TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx.

                                                                             {
  if ( storage.size() <= 1 )
    return 0;
  return storage[0];
}

serialize() [1/2]

void StringSerializer::serialize	(	const std::string &	str,
		std::vector< uint32_t > &	storage
	)

Definition at line 57 of file TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx.

                                                                                     {
  std::vector<std::string> tmp(1, str);
  return serialize(tmp, storage);
}

serialize() [2/2]

void StringSerializer::serialize	(	const std::vector< std::string > &	strings,
		std::vector< uint32_t > &	storage
	)

Serializes vector of strings into vector of integers.

The number of strings (size of input vector) is put first into the stream. In case the strings is an empty vector the 0 is put into the storage.

Parameters

strings
storage	is place where serizlized from of stings is appended to

Definition at line 10 of file TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx.

                                                                                                    {
 
  m_ostream.str(""); // ostream reset
  
  // copy strings into m_ostream with delimiter after each element (even after last element)
  copy(strings.begin(), strings.end(), std::ostream_iterator<std::string>(m_ostream, s_delimiter));
  
  /*  
      unsigned int i;
      for ( i = 0 ; i < strings.size() ; ++i) {
      std::cerr << "ser: " << strings[i] << std::endl;
      }
  */
  
  unsigned sizeToReserve = m_ostream.str().size();
  
  // Pad with '\n'
  unsigned int sizeToPad = getPadding(sizeToReserve);
  
  if ( sizeToPad != 0 ) {
    sizeToReserve += sizeToPad;
    for ( unsigned i = 0 ; i < sizeToPad; i++ )
      m_ostream << s_delimiter;
  }
  m_ostream.flush();
  
  char * carray = new char [sizeToReserve];
  strncpy(carray, m_ostream.str().c_str(), sizeToReserve);
  const uint32_t * uarray = (const uint32_t*) carray;
 
  storage.push_back(strings.size()); // put number of strings first
  storage.insert(storage.end(), &uarray[0], &uarray[sizeToReserve/sizeof(uint32_t)]);
 
  /*
  std::cerr << "reserved = " << sizeToReserve << ", pad = " << sizeToPad
            << ", storage size = " << storage.size() << ", serialized: " << std::endl;
  
  for ( unsigned int i = 0 ; i < sizeToReserve; ++i ) {
    std::cerr << " " << std::hex << (int)carray[i] << std::dec << "(" << (char)carray[i] << ")";
  }
  std::cerr << " " << std::dec << std::endl;
  */
  
  delete[] carray;
 
}

Member Data Documentation

m_istream

std::istringstream StringSerializer::m_istream

private

sstream used in de-serialization

Definition at line 85 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

m_ostream

std::ostringstream StringSerializer::m_ostream

private

sstream used in serialization

Definition at line 84 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

s_delimiter

const char *const StringSerializer::s_delimiter = "\n"

staticprivate

default delimeter which is put between strings from the input vector while serialization happens

Definition at line 86 of file TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h.

---

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

• TrigDataAccess/TrigSerializeResult/TrigSerializeResult/StringSerializer.h
• TrigDataAccess/TrigSerializeResult/src/StringSerializer.cxx