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 <sstream>
#include "ers/ers.hpp"
 
#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