/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/ers/ers-00-00-03/ers/Issue.h

Go to the documentation of this file.

/*
 *  Issue.h
 *  ers
 *
 *  Created by Matthias Wiesmann on 08.12.04.
 *  Copyright 2004 CERN. All rights reserved.
 *
 */

#ifndef ERS_Issue_
#define ERS_Issue_

#include <map>
#include <string>
#include <stdint.h>

#include "ers/Core.h"
#include "ers/Stream.h"
#include "ers/Context.h"
#include "ers/IssueFactory.h"

namespace ers {
    
    class Issue : public std::exception  {  
        friend class Stream ; 
        friend class IssueFactory ; 
public: 
        static const char *const CLASS_KEY ;                               
        static const char *const COMPILATION_TIME_KEY ;                    
        static const char *const COMPILATION_TARGET_KEY ;                  
        static const char *const COMPILER_KEY ;                            
        static const char *const COMPILATION_DEBUG_LVL_KEY ;            
        static const char *const CPP_CLASS_KEY ;                           
        static const char *const ERS_VERSION_KEY ;                         
        static const char *const HOST_NAME_KEY ;                           
        static const char *const HOST_TYPE_KEY ;                           
        static const char *const HOST_IP_ADDR_KEY ;                        
        static const char *const MESSAGE_KEY ;                             
        static const char *const PROCESS_ID_KEY ;                          
        static const char *const PROCESS_PWD_KEY ;                         
        static const char *const PROGRAM_NAME_KEY ;                        
        static const char *const RESPONSIBILITY_KEY ;                      
        static const char *const SEVERITY_KEY ;                            
        static const char *const SOURCE_POSITION_KEY ;                     
        static const char *const SOURCE_PACKAGE_KEY ;                      
        static const char *const TIME_KEY ;                                
        static const char *const TRANSIENCE_KEY ;                          
        static const char *const USER_ID_KEY ;                             
        static const char *const USER_NAME_KEY ;                           
        static const char *const CAUSE_PSEUDO_KEY ;                        
        static const char *const CAUSE_TEXT_KEY ;                          
        static const char *const QUALIFIER_LIST_KEY ;                      
        static const char *const EXIT_VALUE_KEY ;                          
        static const char *const ISSUE_CLASS_NAME ;                        
protected:
            Issue *m_cause ;                                               
        mutable std::string m_class_name ;                             
        mutable std::string m_human_description ;                      
        string_map_type m_value_table  ;                               
        void insert(const Context *context) throw() ;                  
        void insert_time() throw() ;                                   
        void setup_common(const Context *context) throw() ;            
        void finish_setup(const std::string &message) throw() ;        
        Issue(const Context &context, severity_t s);                 
        void set_values(const string_map_type &values) throw();        
public:
            Issue();  
        Issue(const Issue &issue); 
        Issue(const string_map_type &values); 
        Issue(const Context &context, severity_t s, const std::string &message);   
        Issue(const Context &context, severity_t s, const std::exception *cause); 
        virtual ~Issue() throw() ;
        Issue *clone() const ; 
        
        const Issue *cause() const throw() ;                           
        void cause(const std::exception *cause=0);                     
        operator std::string() const ;                                 
        Issue operator=(const Issue &issue);                           
        bool operator==(const Issue &other) const throw();             
        const std::string& operator[](const std::string &key) const throw(); 
        
        const std::string &get_value(const std::string &key, const std::string &def) const throw() ;       
        const std::string &get_value(const std::string &key) const throw(); 
        int get_int_value(const std::string &key, int def=0) const throw() ;       
        long get_long_value(const std::string &key, long def=0) const throw() ;    
        double get_double_value(const std::string key, double def) const throw() ; 
        void set_value(const std::string &key, uint8_t value) throw() ;            
        void set_value(const std::string &key, uint16_t value) throw() ; 
        void set_value(const std::string &key, uint32_t value) throw() ;    
        void set_value(const std::string &key, uint64_t value) throw() ;           
        void set_value(const std::string &key, int8_t value) throw() ;            
        void set_value(const std::string &key, int16_t value) throw() ; 
        void set_value(const std::string &key, int32_t value) throw() ;    
        void set_value(const std::string &key, int64_t value) throw() ;                 
        void set_value(const std::string &key, double value) throw() ;             
        void set_value(const std::string &key, const std::string &value) throw() ; 
        void set_value(const std::string &key, const char* value) throw() ;        
        void set_value(const std::string &key, const void* ptr) throw() ; 
        int values_number() const ;                                                
        virtual const char *get_class_name() const throw() ;           
        const string_map_type* get_value_table() const ;               
        severity_t severity() const throw()  ;                         
        void severity(severity_t s) ;                                  
        bool is_error();                                               
        std::string severity_message() const ;                         
        void responsibility(responsibility_t r) ;                      
        responsibility_t responsibility() const throw() ;              
        void transience(bool tr);                                      
        int transience() const throw() ;                               
        const std::string &human_description() const throw()  ;        
        const char* what() const throw() ;                             
        const std::string &message() const throw() ;                   
        virtual int exit_value() const throw();                        
        void add_qualifier(const std::string &qualif) ;                
        std::vector<std::string> qualifiers() const ;                  
    } ; // Issue

std::ostream& operator<<(std::ostream&, const Issue&);
Stream& operator<<(Stream&, const Issue&); 
} // ers

// This macro suppresses assertion if N_DEBUG is defined 
// 

#if defined(N_DEBUG)
#define N_ERS_STATIC_ASSERT
#define N_ERS_ASSERT
#endif

#endif

---