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

Go to the documentation of this file.

/*
 *  StreamFactory.cxx
 *  ERS
 *
 *  Created by Matthias Wiesmann on 21.01.05.
 *  Copyright 2005 CERN. All rights reserved.
 *
 */

#include <iostream>
#include <cstdlib> 

#include "ers/StreamFactory.h"
#include "ers/DefaultStream.h"
#include "ers/ers.h"


const char* ers::StreamFactory::DEFAULT_STREAMS[] = {
    "null:",                                                          // none
    "default:",  "default:",  "default:", "default:",                 // debug levels
    "default:",  "default:",  "default:",                             // information, notification, warning
    "default:verbose",  "default:verbose",                            // Errors and Fatals
    "null:"  } ;                                                      // max


ers::StreamFactory *ers::StreamFactory::s_instance = 0 ; 


// Constructors & Instance access methods
// --------------------------------------

ers::StreamFactory::StreamFactory() {
   for(int i= static_cast<int> (severity_none);i< static_cast<int> (severity_max);i++) {        
        severity_t s = static_cast<severity_t> (i) ; 
       m_streams[s]=0 ;
   } // for*/
} // StreamFactory

ers::StreamFactory::StreamFactory(const StreamFactory &other) {
    (void) other ; // shut up the compiler 
    ERS_NOT_IMPLEMENTED(); 
} // StreamFactory

ers::StreamFactory::~StreamFactory() {
    for(int i= static_cast<int> (severity_none);i< static_cast<int> (severity_max);i++) {       
        severity_t s = static_cast<severity_t> (i) ; 
        if(m_streams[s]) {
            delete(m_streams[s]);
            m_streams[s]=0 ; 
        } // if stream 
    } // for*/
} // ~StreamFactory


ers::StreamFactory* ers::StreamFactory::instance() {
    if (0==s_instance) {
        s_instance = new StreamFactory(); 
    } // if
    return s_instance ; 
} // instance

void ers::StreamFactory::print_registered() {
    const StreamFactory *factory = instance();
    std::cerr << *factory ; 
} // print_registered

// Static methods
// --------------------------------------


ers::Stream* ers::StreamFactory::get_default_stream(severity_t s) {
    return instance()->get_stream(s) ; 
} // get_default_stream

const char* ers::StreamFactory::key_for_severity(severity_t s) {
    char key_buffer[64] ; 
    snprintf(key_buffer,sizeof(key_buffer),"ERS_%s",ers::Core::to_string(s)) ;
    char *c = &(key_buffer[0]);
    while(*c) {
        *c = toupper(*c) ;
        c++ ;
    } // while
    const char *env = ::getenv(key_buffer) ; 
    if (env!=0) return env ;
    const char* static_key = DEFAULT_STREAMS[s] ; 
    if (static_key) return static_key ; 
    return ers::DefaultStream::KEY ; 
} // key_for_severity

ers::Stream *ers::StreamFactory::create_stream(const std::string &key) const {
    std::string protocol ; 
    std::string uri ; 

    std::string::size_type colon = key.find(':') ; 
    if (colon==std::string::npos) {
        protocol = key ; 
    } else {
        protocol = key.substr(0,colon) ; 
        std::string::size_type uri_start = colon+1 ; 
        if (uri_start<key.size()) {
            uri = key.substr(uri_start) ; 
        } // if
    } // colon present 
    for(stream_factory_collection::const_iterator pos=m_factories.begin();pos!=m_factories.end();++pos) {
        create_stream_callback callback = pos->second; 
        Stream *s = callback(protocol,uri); 
        if (s!=0) return s ; 
    } // for
    fprintf(stderr,"Warning, could not find stream for key protocol=\"%s\" uri=\"%s\" (%s)\n",protocol.c_str(),uri.c_str(),key.c_str()); 
    return new DefaultStream(); 
} // create_stream

ers::Stream *ers::StreamFactory::create_stream(severity_t s) {
    const char* key = key_for_severity(s); 
    return create_stream(key); 
} // get_stream


void ers::StreamFactory::fatal(Issue *issue_ptr) {
    ERS_PRE_CHECK_PTR(issue_ptr); 
    issue_ptr->severity(ers::fatal); 
    dispatch(issue_ptr,false); 
} // fatal

void ers::StreamFactory::error(Issue *issue_ptr) {
    ERS_PRE_CHECK_PTR(issue_ptr); 
    issue_ptr->severity(ers::error); 
    dispatch(issue_ptr,false); 
} // error

void ers::StreamFactory::warning(Issue *issue_ptr) {
    ERS_PRE_CHECK_PTR(issue_ptr); 
    issue_ptr->severity(ers::warning); 
    dispatch(issue_ptr,false); 
} // warning

void ers::StreamFactory::debug(Issue *issue_ptr, severity_t s) {
    ERS_PRE_CHECK_PTR(issue_ptr); 
    ERS_PRECONDITION(s<ers::information,"severity_t is not debug : %s (%d) %d",ers::Core::to_string(s),s,ers::information);
    issue_ptr->severity(s) ; 
    dispatch(issue_ptr,false);
} //  debug

void ers::StreamFactory::debug(const Context &c, const std::string &message, severity_t s) {
    LogIssue log_issue(c,s,message); 
    debug(&log_issue,s); 
} // debug

void ers::StreamFactory::warning(const Context &c, const std::string &message) {
    LogIssue log_issue(c,ers::warning,message);
    warning(&log_issue); 
} // warning


void ers::StreamFactory::dispatch(Issue *issue_ptr, bool throw_error) {
    ERS_PRE_CHECK_PTR(issue_ptr); 
    if (throw_error && issue_ptr->is_error()) { throw *issue_ptr  ; } 
    const severity_t s = issue_ptr->severity() ;
    Stream *stream_ptr =  instance()->get_stream(s) ; 
    ERS_CHECK_PTR(stream_ptr);
    stream_ptr->send(issue_ptr); 
} // dispatch


void ers::StreamFactory::dispatch(Issue &issue_ref, bool throw_error) {
        dispatch(&issue_ref,throw_error); 
} // dispatch


void ers::StreamFactory::set_stream(severity_t s, const std::string &key) {
    instance()->set(s,key.c_str()) ; 
} // set



// Member methods
// --------------------------------------

ers::Stream * ers::StreamFactory::get_stream(severity_t s)  {
    if (m_streams[s]==0) {
        m_streams[s]=create_stream(s) ; 
    } // if 
    return m_streams[s] ; 
} // get_stream


void ers::StreamFactory::set(severity_t severity, Stream *s) {
    ERS_PRE_CHECK_PTR(s); 
    ERS_PRECONDITION(severity_none < severity && severity < severity_max,"illegal severity_t %d",(int) severity);
    if (m_streams[severity]) {
        delete m_streams[severity] ;
    } // if there is a stream defined 
    m_streams[severity] = s ; 
} // stream

void ers::StreamFactory::set(severity_t severity, const char* key) {
    ERS_PRE_CHECK_PTR(key); 
    Stream *s = create_stream(key);
    set(severity,s); 
} // 

ers::Stream *ers::StreamFactory::fatal()  { return get_stream(ers::fatal) ; } // fatal 

ers::Stream* ers::StreamFactory::error()  { return get_stream(ers::error) ; } // error

ers::Stream* ers::StreamFactory::warning()  { return get_stream(ers::warning); } // warning


ers::Stream* ers::StreamFactory::debug(severity_t s)  {
    ERS_PRECONDITION(s<ers::information && s>ers::severity_none,"severity_t is not debug : %s (%d)",ers::Core::to_string(s),s);
    return get_stream(s) ; 
} // debug




bool ers::StreamFactory::register_factory(const std::string &name, create_stream_callback callback) {
    // std::cerr << "registering " << name << std::endl ; 
    m_factories[name] = callback ;
    return true  ;
} // register_factory

void ers::StreamFactory::write_to(std::ostream& stream) const {
    stream << "Stream factory - registered streams\n" ; 
    stream << "-----------------------------------\n" ; 
    int i = 0 ; 
    for(stream_factory_collection::const_iterator pos=m_factories.begin();pos!=m_factories.end();++pos) {
        std::string name = pos->first; 
        stream << i << ")\t" << name << std::endl; 
        i++ ; 
    } // for
    stream << "-----------------------------------\n" ; 
} // write_to


std::ostream& ers::operator<<(std::ostream& stream, const ers::StreamFactory& factory) {
    factory.write_to(stream);
    return stream ; 
} // operator

---