vx.h

Go to the documentation of this file.

/*
 *              vx.h
 *
 *      Copyright 2001 - 2016 Brenton Ross
 *
 *      This file is part of VICI.
 *
 *   VICI 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.
 *
 *   VICI 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 VICI.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef VICI_VX_H
#define VICI_VX_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 VICI
{

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

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

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


template< typename N >
class vxt : public std::runtime_error
{
        // Tests - cfitest - ExceptionTestCase
protected:
        Severity mSeverity;             
        std::string buff;               
        std::string file;               
        int line;                               
        int ptr;                                

public:

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


        vxt( Severity s, const std::string &f, int ln )
                : runtime_error("vici 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:
        // vx x; throw x << "Message" << value << etc;
        // or
        // throw vx( VICI::Alert ) << "message " << strerror( errno );
        //

        template < class T >
        vxt & 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( VICI::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 vici_class;       // matches the namespace

}; // namespace

using vx = VICI::vxt< VICI::vici_class >;

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

#endif  // VX_H

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