StringMemoryArea.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS system source for the DUNE DAQ project.
// Fork baseline commit: system-00-00-20 (2020-09-25).
// Renamed since fork: yes (from src/StringMemoryArea.cxx to src/StringMemoryArea.cpp).
 
/*
 *  StringMemoryArea.cxx
 *  OksSystem
 *
 *  Created by Matthias Wiesmann on 17.02.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */
 
#include "ers/ers.hpp"
#include <sstream>
 
#include "okssystem/StringMemoryArea.hpp"
 
const char OksSystem::StringMemoryArea::STRING_SEPARATOR = (char)3;
const char OksSystem::StringMemoryArea::MAP_ENTRY_SEPARATOR = (char)4;

 
OksSystem::StringMemoryArea::offset_t
OksSystem::StringMemoryArea::add(const char* str)
{
  ERS_PRECONDITION(str);
  const size_t l = strlen(str);
  const offset_t offset = last_string();
  const offset_t start = offset + 1;
  const offset_t end = start + l;
 
  ERS_RANGE_CHECK(1, end, string_area_size());
  char* data = string_area_write();
  char* current = &data[start];
  strcpy(current, str);
  last_string(end);
  return start;
} // add

 
size_t
OksSystem::StringMemoryArea::clear(offset_t offset)
{
  char* data = string_area_write();
  size_t count = 0;
  while (data[count + offset]) {
    data[count + offset] = '\0';
    count++;
  } // while
  return count;
} // clear_string

 
const char*
OksSystem::StringMemoryArea::get_string(offset_t offset) const
{
  if (offset == 0)
    return 0;
  ERS_RANGE_CHECK(1, offset, string_area_size());
  const char* str = string_area_read();
  if (str == NULL) {
    return 0;
  }
  return &(str[offset]);
} // get_string

 
OksSystem::StringMemoryArea::offset_t
OksSystem::StringMemoryArea::insert(offset_t offset, const char* str)
{
  ERS_PRECONDITION(str);
  if (offset == 0)
    return add(str);
  ERS_RANGE_CHECK(1, offset, string_area_size());
  size_t available = clear(offset);
  if (available >= strlen(str)) {
    char* data = string_area_write();
    char* dest = &data[offset];
    strcpy(dest, str);
    return offset;
  } // if
  return add(str);
} // insert_string

 
void
OksSystem::StringMemoryArea::insert(offset_t* offset, const char* str)
{
  ERS_PRECONDITION(offset);
  const offset_t n_offset = insert(*offset, str);
  *offset = n_offset;
} // insert

 
OksSystem::StringMemoryArea::str_vector
OksSystem::StringMemoryArea::get_vector(offset_t offset) const
{
 
  OksSystem::StringMemoryArea::str_vector vector;
  const char* str = get_string(offset);
 
  if (str != 0) {
 
    const std::string text(str);
 
    std::string::size_type start_p = 0;
    std::string::size_type end_p = 0;
 
    while (start_p < text.size()) {
      end_p = text.find(STRING_SEPARATOR, start_p);
      if (end_p == std::string::npos) {
        end_p = text.length();
      }
      std::string extract = text.substr(start_p, end_p - start_p);
      if (extract.size() > 0) {
        vector.push_back(extract);
      }
      start_p = end_p + 1;
    } // while
 
  } // if
 
  return vector;
 
} // get_vector

 
OksSystem::StringMemoryArea::offset_t
OksSystem::StringMemoryArea::insert(offset_t offset, const str_vector& vect)
{
  //    ERS_RANGE_CHECK(0, offset, string_area_size());
  str_vector::const_iterator pos;
  std::ostringstream stream;
  for (pos = vect.begin(); pos != vect.end(); pos++) {
    if (vect.begin() != pos) {
      stream << STRING_SEPARATOR;
    } // if first
    stream << (*pos);
  } // for
  return insert(offset, stream.str().c_str());
} // insert

 
void
OksSystem::StringMemoryArea::insert(offset_t* offset, const str_vector& vect)
{
  ERS_PRECONDITION(offset);
  const offset_t n_offset = insert(*offset, vect);
  *offset = n_offset;
} // insert

 
OksSystem::StringMemoryArea::str_map
OksSystem::StringMemoryArea::get_map(offset_t offset) const
{
 
  ERS_RANGE_CHECK(1, offset, string_area_size());
  OksSystem::StringMemoryArea::str_map map;
  const char* str = get_string(offset);
 
  if (str != 0) {
 
    const std::string text(str);
    std::string::size_type start_p = 0;
    std::string::size_type end_p = 0;
 
    while (start_p < text.size()) {
      end_p = text.find(MAP_ENTRY_SEPARATOR, start_p);
      if (end_p == std::string::npos) {
        end_p = text.length();
      }
      const std::string entry(text.substr(start_p, end_p - start_p));
      const std::string::size_type entrySize = entry.size();
      if (entrySize > 0) {
        const std::string::size_type separator_p = entry.find(STRING_SEPARATOR);
        if (separator_p != std::string::npos) {
          if ((separator_p + 1) < entrySize) {
            map[entry.substr(0, separator_p)] = entry.substr(separator_p + 1);
          } else {
            map[entry.substr(0, separator_p)] = "";
          }
        }
      }
      start_p = end_p + 1;
    } // while
 
  } // if
 
  return map;
 
} // get_map

 
OksSystem::StringMemoryArea::offset_t
OksSystem::StringMemoryArea::insert(offset_t offset, const str_map& map)
{
  //    ERS_RANGE_CHECK(0, offset, string_area_size());
  str_map::const_iterator pos;
  std::ostringstream stream;
  for (pos = map.begin(); pos != map.end(); pos++) {
    if (map.begin() != pos) {
      stream << MAP_ENTRY_SEPARATOR;
    } // if first
    stream << (pos->first);
    stream << STRING_SEPARATOR;
    stream << (pos->second);
  } // for
  return insert(offset, stream.str().c_str());
} // insert

 
void
OksSystem::StringMemoryArea::insert(offset_t* offset, const str_map& map)
{
  ERS_PRECONDITION(offset);
  const offset_t n_offset = insert(*offset, map);
  *offset = n_offset;
} // insert