ErrorCheck.h

Go to the documentation of this file.

/*
 * Expression Template Matrix Library
 *
 * Copyright (C) 2004 - 2006 Ricky Lung <mtlung@users.sourceforge.net>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */


#ifdef _MSC_VER
#   pragma once
#   pragma warning( push )
#   pragma warning( disable : 4100 4267 4714 4786 )
#endif  // _MSC_VER

#ifndef _EXMAT_ERRORCHECK_H
#define _EXMAT_ERRORCHECK_H

#include <stdexcept>
#include <sstream>
#include <string>
#include "Tags.h"
#include "Metaprogramming.h"

namespace exmat {

const char InternalErrMsg[] = "Internal error! Please contact exmat developers.";
const char OutOfBoundsErrMsg[] = "Index out of bounds!";
const char SizeNotPosIntErrMsg[] = "Size should be positive non-zero!";
const char SizeNotMatchErrMsg[] = "Size not match!";
const char IncompatibleErrMsg[] = "Incompatible operation!";
const char CommaInitOutOfBoundErrMsg[] = "Index out of bounds during comma initialization!";

#define THROWMSG(condition, msg, file) if(!(condition)) \
throw(std::runtime_error(std::string(msg) + " At " + file));


template<typename INDEX=NullTag>
class out_of_bound_error : public std::runtime_error {
public:
    EXMAT_INLINE2 explicit out_of_bound_error(const char* str)
        : std::runtime_error(str) {}
    EXMAT_INLINE2 out_of_bound_error(const char* str, INDEX min, INDEX max, INDEX i)
        : std::runtime_error(str), minI(min), maxI(max), index(i) {}
    EXMAT_INLINE2 virtual ~out_of_bound_error() throw()
        {}
    INDEX minI, maxI, index;
};


class compatibility_error : public std::runtime_error {
public:
    EXMAT_INLINE2 explicit compatibility_error(const char* str)
        : std::runtime_error(str) {}
    EXMAT_INLINE2 virtual ~compatibility_error() throw()
        {}
};


class mem_align_error : public std::runtime_error {
public:
    EXMAT_INLINE2 explicit mem_align_error(const char* str)
        : std::runtime_error(str) {}
    virtual ~mem_align_error() throw()
        {}
};


namespace PNS {

static EXMAT_INLINE2 void EmptyAssert_(bool condtion, const char* msg) {
}
static EXMAT_INLINE2 void Assert_(bool condtion, const char* msg) {
    if(!condtion)
        throw std::runtime_error(msg);
}
static EXMAT_INLINE2 void EmptyAssertBounds_(bool condtion) {
}
template<typename INDEX>
static EXMAT_INLINE2 void AssertBounds_(INDEX min, INDEX max, INDEX i) {
    if(i < min || i > max) {
        std::ostringstream out(std::ios_base::out);
        out << OutOfBoundsErrMsg << " Accessing index: " << i << ", with Min: " << min << ", Max: " << max;
        throw out_of_bound_error<INDEX>( out.str().c_str() );
    }
}
static EXMAT_INLINE2 void AssertBounds_(bool condtion) {
    if(!condtion)
        throw out_of_bound_error<>(OutOfBoundsErrMsg);
}
static EXMAT_INLINE2 void EmptyAssertCompat_(bool condtion) {
}
static EXMAT_INLINE2 void AssertCompat_(bool condtion) {
    if(!condtion)
        throw compatibility_error(IncompatibleErrMsg);
}

}   // namespace exmat



struct EmptyErrorChecker
{
    static EXMAT_INLINE2 void Assert(bool condtion, const char* msg) {
    }
    template<typename INDEX>
    static EXMAT_INLINE2 void AssertBounds(INDEX min, INDEX max, INDEX i) {
    }
    static EXMAT_INLINE2 void AssertBounds(bool condtion) {
    }
    static EXMAT_INLINE2 void AssertCompat(bool condtion) {
    }
};


struct DefaultErrorChecker
{
    static EXMAT_INLINE2 void Assert(bool condtion, const char* msg) {
        PNS::Assert_(condtion, msg);
    }
    template<typename INDEX>
    static EXMAT_INLINE2 void AssertBounds(INDEX min, INDEX max, INDEX i) {
    }
    static EXMAT_INLINE2 void AssertBounds(bool condtion) {
    }
    static EXMAT_INLINE2 void AssertCompat(bool condtion) {
        PNS::AssertCompat_(condtion);
    }
};


struct FullErrorChecker
{
    static EXMAT_INLINE2 void Assert(bool condtion, const char* msg) {
        exmat::PNS::Assert_(condtion, msg);
    }
    template<typename INDEX>
    static EXMAT_INLINE2 void AssertBounds(INDEX min, INDEX max, INDEX i) {
        exmat::PNS::AssertBounds_(min, max, i);
    }
    static EXMAT_INLINE2 void AssertBounds(bool condtion) {
        exmat::PNS::AssertBounds_(condtion);
    }
    static EXMAT_INLINE2 void AssertCompat(bool condtion) {
        exmat::PNS::AssertCompat_(condtion);
    }
};


template<class CHK1, class CHK2>
struct ResultantChecker {
    typedef typename
    IF<
        OR_bool<
            ISSAMETYPE<CHK1, FullErrorChecker>::RET,
            ISSAMETYPE<CHK2, FullErrorChecker>::RET
        >::RET,
        FullErrorChecker,
    typename
    IF<
        AND_bool<
            ISSAMETYPE<CHK1, EmptyErrorChecker>::RET,
            ISSAMETYPE<CHK2, EmptyErrorChecker>::RET
        >::RET,
        EmptyErrorChecker,
        DefaultErrorChecker
    >::RET>::RET RET;
};

}   // namespace exmat

#ifdef _MSC_VER
#   pragma warning( pop )
#endif  // _MSC_VER

#endif  // _EXMAT_ERRORCHECK_H

---