jade::basic_assertion< TChar > Class Template Reference

A template for a class that asserts valid conditions. More...

#include <jade.assert.hpp>

Collaboration diagram for jade::basic_assertion< TChar >:

Public Types
typedef TChar	char_type
	The character type. More...
typedef std::basic_string< char_type >	string_type
	The string type. More...

Static Public Member Functions
static void	validate (const bool is_true, char_type const *const expression, char_type const *const file, const int line)
	Validates an expression is true; if not, this method throws an exception. More...

Detailed Description

template<typename TChar>
class jade::basic_assertion< TChar >

A template for a class that asserts valid conditions.

Definition at line 23 of file jade.assert.hpp.

Member Typedef Documentation

char_type

template<typename TChar >

typedef TChar jade::basic_assertion< TChar >::char_type

The character type.

Definition at line 27 of file jade.assert.hpp.

string_type

template<typename TChar >

typedef std::basic_string<char_type> jade::basic_assertion< TChar >::string_type

The string type.

Definition at line 30 of file jade.assert.hpp.

Member Function Documentation

validate()

template<typename TChar >

static void jade::basic_assertion< TChar >::validate ( const bool  is_true, char_type const *const  expression, char_type const *const  file, const int  line  )

inlinestatic

Validates an expression is true; if not, this method throws an exception.

Parameters

is_true	The validated expression.
expression	The expression text.
file	The name of the file.
line	The line number.

Definition at line 36 of file jade.assert.hpp.

        {
            if (is_true)
                return;
 
            auto & err = _err();
            err << file << char_type('(') << line << char_type(')')
                << char_type(':') << char_type(' ') << expression
                << std::endl;
 
            void * addresses[256];
            const auto n = ::backtrace(
                addresses,
                std::extent<decltype(addresses)>::value);
 
            typedef std::unique_ptr<
                char_type *,
                decltype(&std::free)
            > symbols_ptr_type;
 
            const symbols_ptr_type symbols_ptr (
                _backtrace_symbols(addresses, n),
                &std::free);
            const auto symbols = symbols_ptr.get();
 
            for (auto i = 1; i < n; i++)
            {
                const auto symbol = symbols[i];
 
                //
                // Look for the last '+' symbol; if found subract white-space
                // off the end of the mangled function name.
                //
                auto end = symbol;
                while (*end != char_type('\0'))
                    ++end;
                while (end != symbol && *end != char_type('+'))
                    --end;
                while (end > symbol && end[-1] == char_type(' '))
                    --end;
 
                //
                // Loop back until the first white-space symbol or parenthesis
                // symbol is found.
                //
                auto begin = std::max(symbol, end - 1);
                while (
                        begin > symbol &&
                        begin[-1] != char_type(' ') &&
                        begin[-1] != char_type('('))
                    --begin;
 
                //
                // If the mangled name wasn't found, then print the mangled
                // version; otherwise, replace the manged name with the
                // demangled version and print the reformatted line.
                //
                if (begin <= symbol || end <= symbol)
                {
                    err << symbol << std::endl;
                }
                else
                {
                    for (auto p = symbol; p != begin; p++)
                        err << *p;
                    const auto replaced = *end;
                    *end++ = char_type('\0');
 
                    err << _demangle(begin) << replaced << end << std::endl;
                }
            }
 
            throw std::runtime_error("assertion failure");
        }

---

The documentation for this class was generated from the following file:

• jade.assert.hpp