OksSystem::StringMemoryArea Class Reference

String memory storage facility. More...

#include <StringMemoryArea.hpp>

Public Types
typedef unsigned int	offset_t
typedef std::vector< std::string >	str_vector
typedef std::map< std::string, std::string >	str_map

Public Member Functions
offset_t	add (const char *str)
size_t	clear (offset_t offset)
const char *	get_string (offset_t offset) const
offset_t	insert (offset_t offset, const char *str)
void	insert (offset_t *offset, const char *str)
offset_t	insert (offset_t offset, const str_vector &vect)
void	insert (offset_t *offset, const str_vector &vect)
str_vector	get_vector (offset_t offset) const
offset_t	insert (offset_t offset, const str_map &map)
void	insert (offset_t *offset, const str_map &map)
str_map	get_map (offset_t offset) const

Protected Member Functions
virtual const char *	string_area_read () const =0
	read pointer for the string area
virtual char *	string_area_write ()=0
	write pointer for the string area
virtual offset_t	last_string () const =0
	offset of the end of the last string
virtual void	last_string (offset_t offset)=0
	sets the offset of the end of last string
virtual size_t	string_area_size () const =0
	size of the string area

Static Protected Attributes
static const char	STRING_SEPARATOR = (char) 3
	character used to separate strings (i.e., to tokenize strings in vectors)
static const char	MAP_ENTRY_SEPARATOR = (char) 4
	character used to separate map entries

Detailed Description

String memory storage facility.

This class offers facilities to store variable length strings into a memory area. The class can also store vector of strings and arrays. Strings are manipulated using offsets those represent offset in the memory area. As the addresses are relative, they are suitable for use in memory mapped files.

Note

The class is abstract, concrete subclasses need to implement methods that actually manipulate the memory area.

Author

Matthias Wiesmann

Version

1.0

Definition at line 30 of file StringMemoryArea.hpp.

Member Typedef Documentation

offset_t

unsigned int OksSystem::StringMemoryArea::offset_t

Definition at line 32 of file StringMemoryArea.hpp.

str_map

std::map<std::string, std::string> OksSystem::StringMemoryArea::str_map

Definition at line 34 of file StringMemoryArea.hpp.

str_vector

std::vector<std::string> OksSystem::StringMemoryArea::str_vector

Definition at line 33 of file StringMemoryArea.hpp.

Member Function Documentation

add()

OksSystem::StringMemoryArea::offset_t OksSystem::StringMemoryArea::add

(

const char *

str

)

Inserts a string at the end of the string region

Parameters

str	the string to insert

Returns

the offset in the string region of the string

Definition at line 23 of file StringMemoryArea.cpp.

                                                                                {
    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

clear()

size_t OksSystem::StringMemoryArea::clear

(

offset_t

offset

)

Clears a string in the string region

Parameters

offset

the offset of the start of the string

Returns

the lenght of the cleared string

Definition at line 43 of file StringMemoryArea.cpp.

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

get_map()

OksSystem::StringMemoryArea::str_map OksSystem::StringMemoryArea::get_map

(

offset_t

offset

)

const

Reads a string map from memory

Parameters

offset

offset of the map in memory

Returns

a map of strings

Definition at line 176 of file StringMemoryArea.cpp.

                                                                                         {
 
    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

get_string()

const char * OksSystem::StringMemoryArea::get_string

(

offset_t

offset

)

const

Finds a string in the string area

Parameters

offset

the starting offset of the string

Returns

pointer to string

Note

the actual characters are in the shared area

Definition at line 59 of file StringMemoryArea.cpp.

                                                                       {
    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

get_vector()

OksSystem::StringMemoryArea::str_vector OksSystem::StringMemoryArea::get_vector

(

offset_t

offset

)

const

Extracts a vector of string from memory

Parameters

offset

offset of the vector

Returns

a vector of strings

Definition at line 109 of file StringMemoryArea.cpp.

                                                                                               {
 
    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

insert() [1/6]

void OksSystem::StringMemoryArea::insert	(	offset_t *	offset,
		const char *	str )

Inserts a string into memory This version updates the memory reference

Parameters

address	of the offset of the string
str	the string to insert

Definition at line 98 of file StringMemoryArea.cpp.

                                                                        {
    ERS_PRECONDITION(offset); 
    const offset_t n_offset = insert(*offset,str); 
    *offset = n_offset; 
} // insert

insert() [2/6]

void OksSystem::StringMemoryArea::insert	(	offset_t *	offset,
		const str_map &	map )

Inserts a vector into memory This version updates the memory reference

Parameters

address	of the offset of the string
str	the string to insert

Note

the strings should not contain the caracter STRING_SEPARATOR (03)

Definition at line 243 of file StringMemoryArea.cpp.

                                                                           {
    ERS_PRECONDITION(offset); 
    const offset_t n_offset = insert(*offset,map); 
    *offset = n_offset; 
} // insert

insert() [3/6]

void OksSystem::StringMemoryArea::insert	(	offset_t *	offset,
		const str_vector &	vect )

Inserts a vector into memory This version updates the memory reference

Parameters

address	of the offset of the string
str	the string to insert

Note

the strings should not contain the caracter STRING_SEPARATOR (03)

Definition at line 165 of file StringMemoryArea.cpp.

                                                                               {
    ERS_PRECONDITION(offset); 
    const offset_t n_offset = insert(*offset,vect); 
    *offset = n_offset; 
} // insert

insert() [4/6]

OksSystem::StringMemoryArea::offset_t OksSystem::StringMemoryArea::insert	(	offset_t	offset,
		const char *	str )

Inserts a string in the string area.

Parameters

offset	offset of the existing string to replace - 0 means no offset defined
str	the string to insert

Returns

the actual offset where the string was inserted

Note

An existing string is replaced only if the next string can fit in the space. if not, the old string is zeroed and the new string inserted at the end of the area. This can lead to fragmentation, so you should avoid replacing strings.

Definition at line 78 of file StringMemoryArea.cpp.

                                                                                                    {
    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

insert() [5/6]

OksSystem::StringMemoryArea::offset_t OksSystem::StringMemoryArea::insert	(	offset_t	offset,
		const str_map &	map )

Inserts a map into memory

Parameters

offset	current offset of the map
map	the map to insert

Returns

the new offset of the map

Note

the strings should not contain the caracter STRING_SEPARATOR (03)

Definition at line 221 of file StringMemoryArea.cpp.

                                                                                                       {
  //    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

insert() [6/6]

OksSystem::StringMemoryArea::offset_t OksSystem::StringMemoryArea::insert	(	offset_t	offset,
		const str_vector &	vect )

Inserts a vector in the string area

Parameters

offset	the offset of the string
vect	the vector to insert

Note

the strings should not contain the caracter STRING_SEPARATOR (03)

Definition at line 145 of file StringMemoryArea.cpp.

                                                                                                           {
  //    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

last_string() [1/2]

virtual offset_t OksSystem::StringMemoryArea::last_string ( ) const

protectedpure virtual

offset of the end of the last string

last_string() [2/2]

virtual void OksSystem::StringMemoryArea::last_string ( offset_t offset )

protectedpure virtual

sets the offset of the end of last string

string_area_read()

virtual const char * OksSystem::StringMemoryArea::string_area_read ( ) const

protectedpure virtual

read pointer for the string area

string_area_size()

virtual size_t OksSystem::StringMemoryArea::string_area_size ( ) const

protectedpure virtual

size of the string area

string_area_write()

virtual char * OksSystem::StringMemoryArea::string_area_write ( )

protectedpure virtual

write pointer for the string area

Member Data Documentation

MAP_ENTRY_SEPARATOR

const char OksSystem::StringMemoryArea::MAP_ENTRY_SEPARATOR = (char) 4

staticprotected

character used to separate map entries

Definition at line 37 of file StringMemoryArea.hpp.

STRING_SEPARATOR

const char OksSystem::StringMemoryArea::STRING_SEPARATOR = (char) 3

staticprotected

character used to separate strings (i.e., to tokenize strings in vectors)

Definition at line 36 of file StringMemoryArea.hpp.

---

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

• /github/workspace/dunedaq/sourcecode/okssystem/include/okssystem/StringMemoryArea.hpp
• /github/workspace/dunedaq/sourcecode/okssystem/src/StringMemoryArea.cpp