├── .gitignore
├── LICENSE
├── README.md
├── any
    ├── any.hpp
    ├── readme.md
    └── test.cpp
├── functinal_helper
    ├── bind.hpp
    ├── func_traits.hpp
    ├── readme.md
    └── test.cpp
└── optional
    ├── optional.hpp
    ├── optional_test.cpp
    └── readme.md


/.gitignore:
--------------------------------------------------------------------------------
1 | #VS project files
2 | *.v12.suo
3 | *.vcxproj    
4 | *.sdf
5 | *.vcxproj.filters
6 | *.sln
7 | *.vcxproj.user
8 | Debug
9 | Release


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 yufeng Z
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 
23 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ATMPL
 2 | 
 3 | **all library components write in c++11 without any other dependency.**
 4 | 
 5 | at present, this ATMPL--Another Template Meta Programming Library has a little supported  
 6 | 
 7 | features as follow:  
 8 | 
 9 | ### functional_helper  
10 | include function traits and a enhanced bind template class.  
11 | 
12 | ### Any
13 | 
14 | Safe, generic container for single values of different value types. **similar to [boost.Any](http://www.boost.org/doc/libs/1_60_0/doc/html/any.html)** but c++11 version.
15 | 
16 | ### Optional
17 | 
18 | A value-semantic, type-safe wrapper for representing 'optional' (or 'nullable') objects of a given type. An optional object may or may not contain a value of the underlying type. [boost.Optional](http://www.boost.org/doc/libs/1_61_0/libs/optional/doc/html/index.html) C++11 version
19 | 
20 | **all test on VS2015/GCC 5.3.0/Clang 3.8.0**
21 | 
22 | 


--------------------------------------------------------------------------------
/any/any.hpp:
--------------------------------------------------------------------------------
  1 | //
  2 | // Created by bhzyf on 2016/5/2.
  3 | //
  4 | 
  5 | #ifndef CLIONSCIENCE_ANY_HPP
  6 | #define CLIONSCIENCE_ANY_HPP
  7 | #include <type_traits>
  8 | #include <typeinfo>
  9 | 
 10 | namespace ATMPL
 11 | {
 12 | 	class any
 13 | 	{
 14 | 	private:
 15 | 		class placeholder
 16 | 		{
 17 | 		public: // structors
 18 | 
 19 | 			virtual ~placeholder()
 20 | 			{
 21 | 			}
 22 | 
 23 | 		public: // queries
 24 | 
 25 | 			virtual placeholder *clone() const = 0;
 26 | 
 27 | 		};
 28 | 
 29 | 		template<typename _ValueType>
 30 | 		class holder : public placeholder
 31 | 		{
 32 | 		public:
 33 | 			holder(const _ValueType &v)
 34 | 				: _hold(v)
 35 | 			{
 36 | 			}
 37 | 
 38 | 			placeholder *clone() const override
 39 | 			{
 40 | 				return new holder(_hold);
 41 | 			}
 42 | 
 43 | 		public:
 44 | 			_ValueType _hold;
 45 | 		};
 46 | 
 47 | 	public:
 48 | 		any() : _holder(nullptr)
 49 | 		{
 50 | 		}
 51 | 
 52 | 		template<typename _ValueType>
 53 | 		any(const _ValueType &v)
 54 | 			: _holder(new holder<typename std::remove_cv<typename std::decay<const _ValueType>::type>::type>(v))
 55 | 		{
 56 | 		}
 57 | 
 58 | 		// Perfect forwarding of _ValueType
 59 | 		template<typename _ValueType>
 60 | 		any(_ValueType &&v
 61 | 			, typename std::enable_if<!std::is_same<any, typename std::decay<_ValueType>::type>::value, _ValueType>::type* = nullptr
 62 | 			, typename std::enable_if<!std::is_const<_ValueType>::value>::type* = nullptr)
 63 | 			:_holder(new holder< typename std::decay<_ValueType>::type >(std::forward<_ValueType>(v)))
 64 | 		{
 65 | 		}
 66 | 
 67 | 		//copy constructor
 68 | 		any(const any &other)
 69 | 			: _holder(other._holder != nullptr ? other._holder->clone() : nullptr)
 70 | 		{
 71 | 		}
 72 | 
 73 | 		//move constructor
 74 | 		any(any && other)
 75 | 			:_holder(other._holder)
 76 | 		{
 77 | 			other._holder = nullptr;
 78 | 		}
 79 | 
 80 | 		//assignment constructor
 81 | 		any & operator=(const any& other_any)
 82 | 		{
 83 | 			_holder = other_any._holder->clone();
 84 | 			return *this;
 85 | 		}
 86 | 
 87 | 		//move assignment constructor 
 88 | 		any & operator=(any&& other_any)
 89 | 		{
 90 | 			_holder = other_any._holder;
 91 | 			other_any._holder = nullptr;
 92 | 			return *this;
 93 | 		}
 94 | 
 95 | 		~any()
 96 | 		{
 97 | 			delete _holder;
 98 | 			_holder = nullptr;
 99 | 		}
100 | 
101 | 		template<typename _ValueType>
102 | 		static _ValueType cast(any &operand)
103 | 		{
104 | 			typedef typename std::remove_reference<_ValueType>::type nonref;
105 | 			nonref * op = cast<nonref>(&operand);
106 | 			typedef typename std::conditional<std::is_reference<_ValueType>::value, _ValueType,
107 | 				typename std::add_lvalue_reference<_ValueType>::type>::type ref_type;
108 | 			return static_cast<ref_type>(*op);
109 | 		}
110 | 
111 | 	private:
112 | 		template<typename _ValueType>
113 | 		static _ValueType *cast(any *operand)
114 | 		{
115 | 			auto _holder = dynamic_cast<holder<_ValueType> *>(operand->_holder);
116 | 			if (_holder == nullptr)
117 | 				throw std::bad_cast();
118 | 			return &_holder->_hold;
119 | 		}
120 | 
121 | 		template<typename _ValueType>
122 | 		static const _ValueType *cast(const any *operand)
123 | 		{
124 | 			return cast<_ValueType>(const_cast<any *>(operand));
125 | 		}
126 | 
127 | 
128 | 	public:
129 | 		placeholder *_holder;
130 | 	};
131 | 
132 | 
133 | }
134 | #endif //CLIONSCIENCE_ANY_HPP
135 | 


--------------------------------------------------------------------------------
/any/readme.md:
--------------------------------------------------------------------------------
 1 | examples:
 2 | 
 3 | ```c++
 4 | #include <iostream>
 5 | #include <string>
 6 | #include "any.hpp"
 7 | #include <vector>
 8 | using namespace ATMPL;
 9 | 
10 | template<typename _T>
11 | void pod_test(any &v)
12 | {
13 |     std::cout << "any cast to " << typeid(_T).name() << " : " << any::cast<_T>(v) << std::endl;
14 | }
15 | 
16 | any ret()
17 | {
18 |     int i = 1;
19 |     return any(i);
20 | }
21 | 
22 | int main()
23 | {
24 | 
25 | 
26 |     try
27 |     {
28 |         any v(short(1));
29 |         pod_test<short>(v);
30 | 
31 |         any v_int(int(2));
32 |         pod_test<int>(v_int);
33 | 
34 |         any v_long(long(3));
35 |         pod_test<long>(v_long);
36 | 
37 |         any v_longlong((long long)(4));
38 |         pod_test<long long>(v_longlong);
39 | 
40 |         any v_char(char('5'));
41 |         pod_test<char>(v_char);
42 | 
43 |         char str[] = "hello world";
44 |         any v_cptr(str);
45 |         pod_test<char const *>(v_cptr);
46 | 
47 |         any v_string(std::string("HI! string any cast"));
48 |         pod_test<std::string>(v_string);
49 | 
50 |         any any_0;
51 |         any any_1(ret());
52 |         pod_test<int>(any_1);
53 | 
54 |         any any_2(any_1);
55 |         pod_test<int>(any_2);
56 | 
57 |         any any_3 = ret();
58 |         pod_test<int>(any_3);
59 | 
60 |         any any_4 = any_1;
61 |         pod_test<int>(any_4);
62 | 
63 |         any any_5 = any(int(5));
64 |         pod_test<int>(any_5);
65 | 
66 |         std::vector<any> any_vec;
67 |         any_vec.push_back('A');
68 |         any_vec.push_back(short(1));
69 |         any_vec.push_back(int(2));
70 |         any_vec.push_back(str);
71 |         any_vec.push_back(std::string("hello any,world"));
72 |         pod_test<char>(any_vec[0]);
73 |         pod_test<short>(any_vec[1]);
74 |         pod_test<int>(any_vec[2]);
75 |         pod_test<char const *>(any_vec[3]);
76 |         pod_test<std::string>(any_vec[4]);
77 | 
78 |         printf("test passed\n");
79 |     }
80 |     catch (std::bad_cast&e)
81 |     {
82 |         std::cout << e.what()<<" occured when use any\n";
83 |     }
84 | 
85 | 
86 | }
87 | ```


--------------------------------------------------------------------------------
/any/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <string>
 3 | #include "any.hpp"
 4 | #include <vector>
 5 | using namespace ATMPL;
 6 | 
 7 | template<typename _T>
 8 | void pod_test(any &v)
 9 | {
10 |     std::cout << "any cast to " << typeid(_T).name() << " : " << any::cast<_T>(v) << std::endl;
11 | }
12 | 
13 | any ret()
14 | {
15 |     int i = 1;
16 |     return any(i);
17 | }
18 | 
19 | int main()
20 | {
21 | 
22 | 
23 |     try
24 |     {
25 |         any v(short(1));
26 |         pod_test<short>(v);
27 | 
28 |         any v_int(int(2));
29 |         pod_test<int>(v_int);
30 | 
31 |         any v_long(long(3));
32 |         pod_test<long>(v_long);
33 | 
34 |         any v_longlong((long long)(4));
35 |         pod_test<long long>(v_longlong);
36 | 
37 |         any v_char(char('5'));
38 |         pod_test<char>(v_char);
39 | 
40 |         char str[] = "hello world";
41 |         any v_cptr(str);
42 |         pod_test<char const *>(v_cptr);
43 | 
44 |         any v_string(std::string("HI! string any cast"));
45 |         pod_test<std::string>(v_string);
46 | 
47 |         any any_0;
48 |         any any_1(ret());
49 |         pod_test<int>(any_1);
50 | 
51 |         any any_2(any_1);
52 |         pod_test<int>(any_2);
53 | 
54 |         any any_3 = ret();
55 |         pod_test<int>(any_3);
56 | 
57 |         any any_4 = any_1;
58 |         pod_test<int>(any_4);
59 | 
60 |         any any_5 = any(int(5));
61 |         pod_test<int>(any_5);
62 | 
63 |         std::vector<any> any_vec;
64 |         any_vec.push_back('A');
65 |         any_vec.push_back(short(1));
66 |         any_vec.push_back(int(2));
67 |         any_vec.push_back(str);
68 |         any_vec.push_back(std::string("hello any,world"));
69 |         pod_test<char>(any_vec[0]);
70 |         pod_test<short>(any_vec[1]);
71 |         pod_test<int>(any_vec[2]);
72 |         pod_test<char const *>(any_vec[3]);
73 |         pod_test<std::string>(any_vec[4]);
74 | 
75 |         printf("test passed\n");
76 |     }
77 |     catch (std::bad_cast&e)
78 |     {
79 |         std::cout << e.what()<<" occured when use any\n";
80 |     }
81 | 
82 | 
83 | }


--------------------------------------------------------------------------------
/functinal_helper/bind.hpp:
--------------------------------------------------------------------------------
  1 | #include <tuple>
  2 | #include <type_traits>
  3 | #include <functional>
  4 | #include "func_traits.hpp"
  5 | namespace ATMPL
  6 | {
  7 |     
  8 | 
  9 | namespace functional_helper
 10 | {
 11 |     template<class BindExpr, class F, class...Args>
 12 |     struct bind_holder;
 13 | 
 14 |     template<class F>
 15 |     struct is_bind_holder
 16 |         :public std::false_type
 17 |     {};
 18 |     template<class BindExpr, class F, class...Args>
 19 |     struct is_bind_holder<bind_holder<BindExpr,F,Args...>>
 20 |         :public std::true_type
 21 |     {};
 22 | 
 23 |     template<class BindExpr, class F, class...Args>
 24 |     struct is_bind_holder<const bind_holder<BindExpr, F, Args...>>
 25 |         :public std::true_type
 26 |     {};
 27 | 
 28 |     template<class BindExpr, class F, class...Args>
 29 |     struct is_bind_holder<volatile bind_holder<BindExpr, F, Args...>>
 30 |         :public std::true_type
 31 |     {};
 32 | 
 33 |     template<class BindExpr, class F, class...Args>
 34 |     struct is_bind_holder<const volatile bind_holder<BindExpr, F, Args...>>
 35 |         :public std::true_type
 36 |     {};
 37 | 
 38 |     
 39 | 
 40 |     template<class F,bool Is_bind_holder>
 41 |     struct bind_holder_stripper_helper;
 42 | 
 43 |     template<class F>
 44 |     struct bind_holder_stripper_helper<F, false>
 45 |         : public func_traits<F>
 46 |     {};
 47 |     
 48 |     template<class F>
 49 |     struct bind_holder_stripper_helper<F, true>
 50 |         :public bind_holder_stripper_helper<typename F::bind_type, is_bind_holder<typename F::bind_type>::value>
 51 |     {};
 52 | 
 53 |     template<class F>
 54 |     struct bind_holder_stripper
 55 |         :public bind_holder_stripper_helper<F, is_bind_holder<F>::value>
 56 |     {};
 57 | 
 58 |     template<class BindExpr, class F, class...Args>
 59 |     struct bind_holder
 60 |     {
 61 |     private:
 62 |         BindExpr _bind_expr;
 63 |     public:
 64 | 
 65 |         typedef F bind_type;
 66 |         typedef bind_holder_stripper<F> underlying_type;
 67 |         typedef std::integral_constant<size_t, sizeof...(Args)> bind_arity;
 68 |         explicit bind_holder(BindExpr&& _functor)
 69 |             :_bind_expr(std::move(std::forward<BindExpr>(_functor)))
 70 |         {
 71 |         }
 72 | 
 73 |         template<size_t N>
 74 |         struct bind_arg
 75 |         {
 76 |             static_assert(N < bind_arity::value, "error: invalid parameter index.");
 77 |             using type = typename std::tuple_element<N, std::tuple<Args...>>::type;
 78 |         };
 79 | 
 80 |         template<typename... _Args>
 81 |         auto operator()(_Args&&...params)
 82 |             ->decltype(this->_bind_expr(std::forward<_Args>(params)...))
 83 |         {
 84 |             return this->_bind_expr(std::forward<_Args>(params)...);
 85 |         }
 86 |     };
 87 | 
 88 | 	template <typename T>
 89 | 	struct remove_cvr
 90 | 	{
 91 | 		using type = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 92 | 	};
 93 | 
 94 |     template<class F, typename...Args>
 95 |     auto bind(F&& f, Args&&... args)
 96 |         ->decltype((bind_holder<decltype(std::bind(std::forward<F>(f), std::forward<Args>(args)...)),
 97 |         typename remove_cvr<F>::type, Args...>
 98 |                 (std::bind(std::forward<F>(f), std::forward<Args>(args)...))))
 99 |     {
100 |         return (bind_holder<decltype(std::bind(std::forward<F>(f), std::forward<Args>(args)...)),
101 |             typename remove_cvr<F>::type, Args...>
102 |                         (std::bind(std::forward<F>(f), std::forward<Args>(args)...)));
103 |     }
104 | }
105 | 
106 | }


--------------------------------------------------------------------------------
/functinal_helper/func_traits.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <tuple>
 3 | #include <type_traits>
 4 | 
 5 | namespace ATMPL
 6 | {
 7 | 
 8 | 	namespace functional_helper
 9 | 	{
10 | 		template<typename _T>
11 | 		struct func_traits;
12 | 
13 | 		//function
14 | 		template<typename _Ret, typename... _Args>
15 | 		struct  func_traits<_Ret(_Args...)>
16 | 		{
17 | 			typedef _Ret ret;
18 | 			typedef std::integral_constant<size_t, sizeof...(_Args)> arity;
19 | 			template<size_t N>
20 | 			struct arg
21 | 			{
22 | 				static_assert(N < arity::value, "invalid parameter index");
23 | 				using type = typename std::tuple_element<N, std::tuple<_Args...>>::type;
24 | 			};
25 | 		};
26 | 
27 | 		//function pointer
28 | 		template<typename _Ret, typename... _Args>
29 | 		struct  func_traits<_Ret(*)(_Args...)> :public func_traits<_Ret(_Args...)>
30 | 		{
31 | 		};
32 | 
33 | 		//member function pointer
34 | 		template<typename _Ret, class _Class, typename... _Args>
35 | 		struct  func_traits<_Ret(_Class::*)(_Args...)> :public func_traits<_Ret(_Class&, _Args...)>
36 | 		{
37 | 		};
38 | 
39 | 		template<typename _Ret, class _Class, typename... _Args>
40 | 		struct  func_traits<_Ret(_Class::*)(_Args...) const> :public func_traits<_Ret(_Class&, _Args...)>
41 | 		{
42 | 		};
43 | 
44 | 
45 | 		//functor and lambda
46 | 		template<class _Class>
47 | 		struct  func_traits : public func_traits<decltype(&_Class::operator())>
48 | 		{
49 | 		};
50 | 
51 | 	}
52 | 
53 | 
54 | }


--------------------------------------------------------------------------------
/functinal_helper/readme.md:
--------------------------------------------------------------------------------
 1 | ### functional_helper
 2 | 
 3 | include function traits and a enhanced bind template class.  
 4 | 
 5 | ##### function_traits
 6 | 
 7 |  it provide a template class named function_traits<template T>. 
 8 | you can obtain type information on compile-time like return type, 
 9 | arguments' type. it support function pointer,member function pointer, 
10 | member object pointer,lambda and functor.(no support for bind expression,see next).  
11 | 
12 | ##### bind--enhanced std::bind
13 | 
14 |  this version of bind also supports whatever std::bind supports for binding. 
15 | it allow you obtain type information of the bonded callable objects as function_traits provided. 
16 | bind::underlying_type is the very original callable type. it can obtain very original callable type information 
17 | of any recursive bind(not std::bind) you have made.  
18 | 
19 |   
20 | 
21 | all of it programmed with standard c++11. 
22 | this library supports any compilers as long as they support c++11 standard.
23 | 
24 |   
25 | 
26 | examples:
27 | 
28 | ```c++ 
29 | void test(int,char*){}
30 | auto f1 = functional_helper::bind(test, _1,_2);
31 | auto f2 = functional_helper::bind(f1, _1, _2);
32 | auto test_lambda = [](int, char*)->void{};
33 | ```
34 | 
35 | obtain argument: 
36 | 
37 | ```c++
38 | functional_helper::function_traits<decltype(test)>::arg<1>::type//char*
39 | decltype(f1)::underlying_type::arg<1>::type //char*
40 | decltype(f2)::underlying_type::arg<1>::type //char*
41 | decltype(test_lambda)::underlying_type::arg<1>::type //char*
42 | f1(1,'A');
43 | f2(2,'B');
44 | test_lambda(1,'C');
45 | ```
46 | 
47 | 


--------------------------------------------------------------------------------
/functinal_helper/test.cpp:
--------------------------------------------------------------------------------
 1 | #include <type_traits>
 2 | #include <functional>
 3 | #include "bind.hpp"
 4 | using namespace ATMPL::functional_helper;
 5 | int test(int, long*)
 6 | {
 7 | 	return 0;
 8 | }
 9 | class test_class
10 | {
11 | public:
12 |     test_class(){}
13 |     ~test_class(){}
14 |     void test(int, char*){}
15 | };
16 | using namespace std::placeholders;
17 | using namespace ATMPL;
18 | void bind_holder_test()
19 | {
20 | 	auto f1 = functional_helper::bind(test, _1, _2);
21 | 	auto f2 = functional_helper::bind(f1, _1, _2);
22 | 	auto f3 = functional_helper::bind(f1, _1, _2);
23 | 	f1(1, nullptr);
24 | 	f2(1, nullptr);
25 | 	f3(1, nullptr);
26 | 	static_assert(std::is_same<decltype(f1), decltype(f2)::bind_type>::value, "");
27 | 	static_assert(std::is_same<decltype(f1)::underlying_type::arg<1>::type, long*>::value, "");
28 | 	static_assert(std::is_same<bind_holder_stripper<decltype(f3)>::arg<1>::type, long*>::value, "");
29 | 	static_assert(std::is_same<bind_holder_stripper<decltype(f3)>::arg<1>::type, decltype(f3)::underlying_type::arg<1>::type>::value, "");
30 | }
31 | 
32 | 
33 | class T
34 | {
35 | public:
36 | 	short test(long) const
37 | 	{
38 | 		return 1;
39 | 	}
40 | 	static void test1(char) {}
41 | 	long long operator() (int) const
42 | 	{
43 | 		return 1;
44 | 	}
45 | };
46 | 
47 | void function_traits_test()
48 | {
49 | 	T t;
50 | 	auto p = [](int, const char*, long*)->int {
51 | 		return 0;
52 | 	};
53 | 	auto bind_func = std::bind(test, 1, std::placeholders::_1, std::placeholders::_2);
54 | 	typedef decltype(&T::test)  mem_func_pointer;
55 | 	typedef decltype(test)  func;
56 | 	typedef decltype(&test)  func_pointer;
57 | 	typedef decltype(t)  functor;
58 | 	typedef decltype(p)  lambda_type;
59 | 	typedef decltype(&lambda_type::operator())  lambda;
60 | 	typedef decltype(bind_func) bind_expr;
61 | 	printf("%s\n", typeid(func_traits<mem_func_pointer>::arg<1>::type).name());
62 | 	printf("%s\n", typeid(func_traits<func>::ret).name());
63 | 	printf("%s\n", typeid(func_traits<func_pointer>::arg<0>::type).name());
64 | 	printf("%s\n", typeid(func_traits<functor>::arg<1>::type).name());
65 | 	printf("%s\n", typeid(func_traits<lambda>::arg<2>::type).name());
66 | 	printf("%s\n", typeid(func_traits<lambda_type>::arg<3>::type).name());
67 | 	printf("%s\n", typeid(lambda_type).name());
68 | 	printf("%s\n", typeid(lambda).name());
69 | 	printf("%s\n", typeid(bind_expr).name());
70 | 
71 | 
72 | 
73 | 	static_assert(std::is_same<func_traits<mem_func_pointer>::arg<1>::type, long>::value, "");
74 | 	static_assert(std::is_same<func_traits<func>::ret, int>::value, "");
75 | 	static_assert(std::is_same<func_traits<func_pointer>::arg<0>::type, int>::value, "");
76 | 	static_assert(std::is_same<func_traits<functor>::arg<1>::type, int>::value, "");
77 | 	static_assert(std::is_same<func_traits<lambda>::arg<2>::type, const char*>::value, "");
78 | }


--------------------------------------------------------------------------------
/optional/optional.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | #include <type_traits>
 3 | #include <typeinfo>
 4 | namespace ATMPL
 5 | {
 6 | 	template<typename _T>
 7 | 	class optional
 8 | 	{
 9 | 	private:
10 | 		typedef typename std::decay<_T>::type storage_type;
11 | 		typename std::aligned_storage<sizeof(storage_type), alignof(storage_type)>::type storage;
12 | 		bool initialized;
13 | 	public:
14 | 		optional()
15 | 			:initialized(false) {}
16 | 
17 | 		optional(storage_type value)
18 | 		{
19 | 			//std::cout << "convertion\n";
20 | 			::new (&storage) storage_type(std::forward<storage_type>(value));
21 | 			initialized = true;
22 | 		}
23 | 
24 | 		optional(const optional& opl)
25 | 		{
26 | 			//std::cout << "copy constructor\n";
27 | 			initialized = opl.initialized;
28 | 			if (initialized)
29 | 				::new(&storage) storage_type(*opl);
30 | 		}
31 | 
32 | 		optional(optional&& opl)
33 | 		{
34 | 			//std::cout << "move constructor\n";
35 | 			initialized = opl.initialized;
36 | 			if (initialized)
37 | 				::new(&storage) storage_type(std::move(*opl));
38 | 		}
39 | 
40 | 		optional& operator=(optional && opl)
41 | 		{
42 | 			//std::cout << "asign move\n";
43 | 			if (this == &opl)
44 | 				return *this;
45 | 			initialized = opl.initialized;
46 | 			if (initialized)
47 | 				::new(&storage) storage_type(std::move(*opl));
48 | 			return *this;
49 | 		}
50 | 
51 | 		optional& operator=(const optional & opl)
52 | 		{
53 | 			//std::cout << "asign copy\n";
54 | 			if (this == &opl)
55 | 				return *this;
56 | 			initialized = opl.initialized;
57 | 			if (initialized)
58 | 				::new(&storage) storage_type(*const_cast<optional &>(opl));
59 | 			return *this;
60 | 		}
61 | 
62 | 		explicit  operator bool() const
63 | 		{
64 | 			return initialized;
65 | 		}
66 | 
67 | 		bool operator !() const
68 | 		{
69 | 			return !initialized;
70 | 		}
71 | 
72 | 		storage_type operator *() const
73 | 		{
74 | 			return reinterpret_cast<const storage_type&>(storage);
75 | 		}
76 | 
77 | 		template<typename _Type>
78 | 		operator optional<_Type>() const
79 | 		{
80 | 			return static_cast<_Type>(reinterpret_cast<const storage_type&>(storage));
81 | 		}
82 | 
83 | 		template<typename _Type>
84 | 		operator _Type() const
85 | 		{
86 | 			return static_cast<_Type>(reinterpret_cast<const storage_type&>(storage));
87 | 		}
88 | 	};
89 | }


--------------------------------------------------------------------------------
/optional/optional_test.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "optional.hpp"
 3 | ATMPL::optional<int> optional_ret()
 4 | {
 5 | 	ATMPL::optional<int> a(15);
 6 | 	return a;
 7 | }
 8 | int optional_test()
 9 | {
10 | 	//constructor test
11 | 	ATMPL::optional<int> explicit_conv_T(12);
12 | 	ATMPL::optional<int> copy_constr(explicit_conv_T);
13 | 	ATMPL::optional<int> move_constr(optional_ret());
14 | 	ATMPL::optional<int> asign_copy;
15 | 	asign_copy = move_constr;
16 | 	ATMPL::optional<int> asign_move;
17 | 	asign_move = optional_ret();
18 | 
19 | 	//cast test
20 | 	ATMPL::optional<int> int_ = 1;
21 | 	int_ = 'f';
22 | 	ATMPL::optional<char> char_ = 's';
23 | 	int_ = char_;
24 | 	std::cout << *int_<<"\n";
25 | 	return 0;
26 | }


--------------------------------------------------------------------------------
/optional/readme.md:
--------------------------------------------------------------------------------
 1 | examples:
 2 | 
 3 | ```c++
 4 | ATMPL::optional<int> int_;
 5 | if(int_)
 6 |   std::cout<<*int_;//it woulnd not get here!
 7 | int_ = 'f';
 8 | ATMPL::optional<char> char_ = 's';
 9 | int_ = char_;
10 | std::cout << *int_<<"\n";
11 | ```


--------------------------------------------------------------------------------