sx.h

Go to the documentation of this file.

/*
 *              sx.h
 *
 *      Copyright 2001 - 2017 Brenton Ross
 *
 *      This file is part of SASSY.
 *
 *   SASSY is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 *
 *   SASSY is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with SASSY.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef SASSY_SX_H
#define SASSY_SX_H

#include <stdexcept>
#include <string>
#include <sstream>
#include <vector>

// these included here since its normal to include the reason for the failure
// by calling strerror(errno)
#include <errno.h>
#include <string.h>

// ------------------------------------------------------------------

namespace SASSY
{

// ------------------------------------------------------------------

enum Severity {
        Emergency,              
        Alert,                  
        Critical,               
        Error,                  
        Code,                   
        Warning,                
        Notice,                 
        Info,                   
        Debug                   
};

// ------------------------------------------------------------------


template< typename N >
class sxt : public std::runtime_error
{
protected:
        Severity mSeverity;             
        std::string buff;               
        std::string file;               
        int line;                               
        int ptr;                                

public:

        explicit sxt( Severity s )
                : runtime_error("sassy error"), mSeverity(s), line(0)
                {
                        buff = sevToString(s) + ": ";
                        ptr = 0;
                }


        sxt( Severity s, const std::string &f, int ln )
                : runtime_error("sassy error"), mSeverity(s), file(f), line(ln)
        {
                buff = sevToString(s) + ": ";
                ptr = buff.length();
                if ( ! file.empty() )
                {
                        std::ostringstream ss;
                        ss << " [" << file << ":" << line << "]";
                        buff.append( ss.str() );
                        file.clear();
                }
        }


        //
        // Use this one like this:
        // sx x; throw x << "Message" << value << etc;
        // or
        // throw sx( SASSY::Alert ) << "message " << strerror( errno );
        //

        template < class T >
        sxt & operator << ( T x )
        {
                std::ostringstream ss;
                ss << x;
                if ( ptr )
                {
                        buff.insert( ptr, ss.str() );
                        ptr += ss.str().length();
                }
                else
                {
                        buff.append( ss.str() );
                }

                return *this;
        }

        Severity severity() { return mSeverity; }

        virtual const char *what() const throw()
        {
                return buff.c_str();
        }

        static const std::string & sevToString( SASSY::Severity s)
        {
                static std::vector< std::string >snames;
                if ( snames.size() == 0)
                {
                        snames.push_back( "Emergency" );
                        snames.push_back( "Alert" );
                        snames.push_back( "Critical" );
                        snames.push_back( "Error" );
                        snames.push_back( "Code" );
                        snames.push_back( "Warning" );
                        snames.push_back( "Notice" );
                        snames.push_back( "Info" );
                        snames.push_back( "Debug" );
                }
                return snames[(int)s];
        }


        //void log( Severity sev )
                //{ doLog( sev ); }

        //void log()
                //{ doLog( mSeverity ); }


        //void log( const std::string &msg )
                //{ doLog( mSeverity, msg ); }
};

// ----------------------------------------------------

class sassy_class;      // matches the namespace

}; // namespace

using sx = SASSY::sxt< SASSY::sassy_class >;

// defined method so that file and line number are passed correctly.
// typically used like: throw SX(Error) << "message: " << strerror(errno);
#define SX(x) sx(x, __FILE__, __LINE__ )

#endif  // SX_H

// ----------------------------- end --------------------------------