wrappers.hpp File Reference

#include <alps/config.hpp>
#include <alps/accumulators/feature/mean.hpp>
#include <alps/accumulators/feature/error.hpp>
#include <alps/accumulators/feature/count.hpp>
#include <alps/accumulators/feature/max_num_binning.hpp>
#include <alps/accumulators/feature/binning_analysis.hpp>
#include <alps/hdf5/archive.hpp>
#include <boost/variant/variant.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <typeinfo>
#include <type_traits>
#include <stdexcept>

Include dependency graph for wrappers.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	alps::accumulators::derived_wrapper< A >
class	alps::accumulators::base_wrapper< T >
class	alps::accumulators::derived_wrapper< A >
class	alps::accumulators::derived_result_wrapper< A >
class	alps::accumulators::derived_accumulator_wrapper< A >

Namespaces
	alps
	alps::accumulators

Macros
#define	OPERATOR_PROXY(AUGOPNAME, AUGOP, AUGOPFN)
#define	FUNCTION_PROXY(FUN)
#define	FUNCTION_PROXY(FUN)

Functions
template<typename T , typename A >
derived_result_wrapper< A >	alps::accumulators::operator/ (T arg, derived_result_wrapper< A > res)

Macro Definition Documentation

#define FUNCTION_PROXY

(

FUN

)

Value:

void FUN () {                                                                   \
                        this->m_data. FUN ();                                                       \
                    }

Definition at line 368 of file wrappers.hpp.

#define FUNCTION_PROXY

(

FUN

)

Value:

void FUN () {                                                                                                                     \
                        throw std::runtime_error("The Function " #FUN " is not implemented for accumulators, only for results" + ALPS_STACKTRACE);    \
                    }

Definition at line 368 of file wrappers.hpp.

#define OPERATOR_PROXY	(		AUGOPNAME,
			AUGOP,
			AUGOPFN
	)

Value:

void AUGOPNAME(base_wrapper<typename value_type<A>::type> const & arg) {        \
                        this->m_data AUGOP arg.template extract<A>();                               \
                    }                                                   \                                                    \
                    void do_##AUGOPFN(void*) {                           \
                        throw std::logic_error("This virtual method plug should never be called"); \
                    }                                                               \
                    template <typename W>                               \
                    void do_##AUGOPFN(W& arg) {                           \
                        this->m_data AUGOP arg.template extract<typename A::scalar_result_type>();          \
                    }                                                               \
                    void AUGOPNAME(wrapped_scalar_value_type arg) {        \
                        do_##AUGOPFN(arg);                               \
                    }                                                                               \
                    /* takes `long double`: it's the widest scalar numeric type */                  \
                    void AUGOPNAME(long double arg) {                                               \
                        this->m_data AUGOP arg;                                                     \
                    }

Definition at line 247 of file wrappers.hpp.