except.h

Go to the documentation of this file.

/* RDF C++ API 
 *
 *                      except.h
 *
 *      Copyright 2001 - 2017           Brenton Ross
 *
 * -----------------------------------------------------------------------------
 * LICENSE
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library 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 this library. If not, see <http://www.gnu.org/licenses/>.
 * 
 * -----------------------------------------------------------------------------
 */



#ifndef RDFXX_VX_H
#define RDFXX_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 rdf
{

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

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

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


template< typename N >
class vxt : public std::runtime_error
{
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( 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];
        }

};

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

class rdf_class;        // matches the namespace

} // namespace rdf

using vx = rdf::vxt< rdf::rdf_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 --------------------------------