mn_stl.hpp

Go to the documentation of this file.

 
#ifndef __MINILIB_STL_FUNCTIONS_H__
#define __MINILIB_STL_FUNCTIONS_H__
 
namespace mn {
    namespace stl {
        template <typename T>
        struct type_traits {
            using value_type = T;
            using const_type = const T;
            using reference = T&;
            using const_reference = const T&;
            using pointer = T*;
            using const_pointer = const T*;
        };
 
        template <typename T>
        struct type_traits<T&> {
            using value_type = T;
            using const_type = const T;
            using reference = T&;
            using const_reference = const T&;
            using pointer = T*;
            using const_pointer = const T*;
        };
 
        template <typename T>
        struct type_traits<const T> {
            using value_type = T;
            using const_type = const T;
            using reference = T&;
            using const_reference = const T&;
            using pointer = T*;
            using const_pointer = const T*;
        };
 
        template <typename T>
        struct type_traits<const T&> {
            using value_type = T;
            using const_type = const T;
            using reference = T&;
            using const_reference = const T&;
            using pointer = T*;
            using const_pointer = const T*;
        };
 
 
 
        template<class T, T v> struct integral_constant {
            enum { value = v  };
        };
 
        using  true_type = integral_constant<bool, true>;
        using false_type =  integral_constant<bool, false> ;
 
        template<typename Arg, typename TResult>
        struct unary_function {
          using argument_type = Arg;
          using result_type =  TResult;
        };
 
 
        template<typename Arg1, typename Arg2, typename TResult>
        struct binary_function {
            using first_argument_type = Arg;
            using second_argument_type = Arg2;
            using result_type =  TResult;
        };
 
        template<typename T>
        struct negate : public unary_function<T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a) const noexcept { return -a; }
        };
 
        template<typename T>
        struct plus : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const  noexcept { return a + b; }
        };
 
        template<typename T>
        struct minus : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a - b; }
        };
 
        template<typename T>
        struct multiplies : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a * b; }
        };
 
        template<typename T>
        struct divides : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a / b; }
        };
 
        template<typename T>
        struct modulus : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a % b; }
        };
 
        template<typename T>
        struct equal_to : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a == b; }
        };
 
        template<typename T>
        struct not_equal_to : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a != b; }
        };
 
        template<typename T>
        struct greater : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a > b; }
        };
 
        template<typename T>
        struct less : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a < b; }
        };
 
        template<typename T>
        struct greater_equal : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a >= b; }
        };
 
        template<typename T>
        struct less_equal : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a <= b; }
        };
 
        template<typename T>
        struct logic_and : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            bool operator()(const T& a, const T& b) const noexcept { return a && b; }
        };
 
        template<typename T>
        struct logic_or : public binary_function<T, T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a || b; }
        };
 
        template<typename T>
        struct logic_not : public unary_function<T, bool> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a) const noexcept { return !a; }
        };
 
        template<typename T>
        struct bit_and : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a & b; }
        };
 
        template<typename T>
        struct bit_or : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a | b; }
        };
 
        template<typename T>
        struct bit_xor : public binary_function<T, T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a, const T& b) const noexcept { return a ^ b; }
        };
 
        template<typename T>
        struct bit_not : public unary_function<T, T> {
            typename binary_function<T, T, T>::result_type
            operator()(const T& a) const noexcept { return ~a; }
        };
 
 
 
        template <typename T>
        struct is_reference : false_type { };
 
        template <typename T>
        struct is_reference<T%> : true_type { };
 
        template <typename T>
        struct is_reference<const T%> : true_type { };
 
        template <typename T>
        struct is_const : false_type { };
 
        template <typename T>
        struct is_const<const T> : true_type { };
 
        template <typename T>
        struct is_const<const T&> : true_type { };
 
        template <typename T, int n>
        struct is_const<const T[n]> : true_type { };
 
        template<typename>
        struct is_volatile : public false_type { };
 
        template<typename _Tp>
        struct is_volatile<_Tp volatile> : public true_type { };
 
        template<typename T>
        struct is_empty : public integral_constant<bool, __is_empty(T)> { };
 
 
        template<typename T>
        struct is_enum : public integral_constant<bool, __is_enum(T)> { };
 
        template<typename T>
        struct is_union : public integral_constant<bool, __is_union(T)> { };
 
        template<typename T>
        struct is_class : public integral_constant<bool, __is_class(T)> { };
 
 
    }
}
 
#endif // __MINILIB_STL_FUNCTIONS_H__