HLT::StringSerializer Namespace Reference

Functions
void	serialize (const std::vector< std::string > &strings, std::vector< uint32_t > &storage)
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)
std::size_t	deserialize (std::vector< uint32_t >::const_iterator first, std::vector< uint32_t >::const_iterator last, std::string &str)

Function Documentation

deserialize() [1/2]

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

Definition at line 103 of file TrigEvent/TrigNavStructure/Root/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() [2/2]

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

Definition at line 66 of file TrigEvent/TrigNavStructure/Root/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]);
  
    const char * carray = (const char*)uarray;
    std::string whole(carray, (storageSize-1)*sizeof(uint32_t));
    std::istringstream istream;
 
    istream.clear();  // istream reset
    istream.str(whole);
 
    std::string one;
    unsigned int readInStrings=0;
    std::size_t nChars=0;
  
    while ( istream.good() && readInStrings < numOfStrings ) {
      getline(istream, one, 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)
  }

serialize() [1/2]

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

Definition at line 60 of file TrigEvent/TrigNavStructure/Root/StringSerializer.cxx.

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

serialize() [2/2]

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

Definition at line 31 of file TrigEvent/TrigNavStructure/Root/StringSerializer.cxx.

                                                                                      {
    std::ostringstream ostream;
    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>(ostream, delimiter));
    
    unsigned sizeToReserve = ostream.str().size();
  
    // Pad with '\n'
    unsigned int sizeToPad = getPadding(sizeToReserve);
  
    if ( sizeToPad != 0 ) {
      sizeToReserve += sizeToPad;
      for ( unsigned i = 0 ; i < sizeToPad; i++ )
    ostream << delimiter;
    }
    ostream.flush();
  
    char * carray = new char [sizeToReserve];
    strncpy(carray, 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)]);
  
    delete[] carray;
  }