/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/ers/ers-00-00-03/src/Core.cxx

Go to the documentation of this file.

#include <ctype.h>
#include <string.h>

#include <iostream>
#include <sstream>
#include <string.h>
#include "ers/Core.h"
#include <cstdlib> 
#include <assert.h>

const char* const ers::Core::SEVERITY_NAMES[] = { "none", "debug_0", "debug_1", "debug_2", "debug_3", "information", "notification", "warning", "error", "fatal", "maximum (illegal)" } ;
const char* const ers::Core::BOOLEAN_NAMES[] = { "false", "true" } ; 
const char* const ers::Core::RESPONSIBILITY_NAMES[] = { "precondition", "internal", "subSystem" } ; 
const std::string ers::Core::empty_string = "" ;

const char *ers::Core::to_string(ers::severity_t s) throw() {
    const unsigned int index = (unsigned int) s ;
    assert(index<=severity_max); 
    return ers::Core::SEVERITY_NAMES[index] ; 
} // getSeverityText

ers::severity_t ers::Core::parse_severity(const char *s) throw() {
    for(int i=0;i<severity_max;i++) {
        if (strcmp(s,ers::Core::SEVERITY_NAMES[i])==0) return (ers::severity_t) i ; 
    }// for
    return severity_none ; 
} // parse_severity

ers::severity_t ers::Core::parse_severity(const std::string &s) throw() {
    return parse_severity(s.c_str());
} // parse_severity

const char* ers::Core::to_string(ers::responsibility_t  r) throw() {
    const unsigned int index = (unsigned int) r ;
    assert(index<=resp_max);
    return RESPONSIBILITY_NAMES[index] ;
} // to_string

ers::responsibility_t  ers::Core::parse_responsibility(const char *s) throw() {
    for(int i=0;i<resp_max;i++) {
        if (strcmp(s,RESPONSIBILITY_NAMES[i])==0) return (ers::responsibility_t) i ; 
    } // for 
    return resp_unknown ;
} // parse_responsability

ers::responsibility_t  ers::Core::parse_responsibility(const std::string &s) throw() {
    return parse_responsibility(s.c_str()) ; 
} // parse_responsability

int ers::Core::parse_boolean(const char* s) throw() {
    if (! s) return -1 ; 
    if (! *s) return -1 ; 
    if (strcasecmp(s,BOOLEAN_NAMES[1])==0) return 1 ;
    if (strcasecmp(s,BOOLEAN_NAMES[0])==0) return 0 ; 
    return -1 ; 
} // parse_boolean

const char* ers::Core::to_string(bool b) throw () {
    int index = b ? 1 : 0 ;
    return BOOLEAN_NAMES[index] ;
} // to_string


std::string ers::Core::parse_prefix_string(const char **ptr) throw() {
    if (ptr==0 || *ptr==0 || **ptr=='\0') return ers::Core::empty_string ; 
    int l = 0 ; 
    while(isdigit(**ptr)) { // we parse the integer 
        l*=10 ;
        l+=(**ptr)-'0' ; 
        (*ptr)++ ; 
    } // 
    std::string s(*ptr,l); // we create the string 
    (*ptr)+=l ; 
    return s ; 
} // parse_gcc_string


std::string ers::Core::umangle_gcc_class_name(const char* name) throw() {
    if (name==0 || strlen(name)==0) return ers::Core::empty_string ; 
    const char *ptr = name ; 
    std::ostringstream stream ; 
    while (*ptr=='P') { // pointers are denoted with P
        stream << "*" ;
        ptr++ ; 
    } // if
    while (*ptr=='N') { // namespace are denoted by N+string 
        ptr++ ; 
        stream << parse_prefix_string(&ptr) << "::" ; 
    } // 
    stream << parse_prefix_string(&ptr);
    return stream.str(); 
} // umangle_gcc_class_name

std::vector<std::string> ers::Core::tokenize(const std::string &text, const std::string &separators) {
    std::vector<std::string> result_vector ; 
    std::string::size_type start_p, end_p ; 
    start_p = text.find_first_not_of(separators) ; 
    while(start_p != std::string::npos) {
        end_p = text.find_first_of(separators,start_p) ;
        if (end_p == std::string::npos) {
            end_p = text.length(); 
        }
        const std::string sub_str = text.substr(start_p,end_p-start_p);
        result_vector.push_back(sub_str) ; 
        start_p = text.find_first_not_of(separators,end_p) ;
    } // while
    return result_vector ; 
} // tokenize

---