#pragma once

#ifdef USE_BOOST

#include <boost/optional.hpp>

#include <boost/utility/typed_in_place_factory.hpp>

#define GIT_USE_BOOST_OPTIONAL

#elif defined(__has_include) && __has_include(<optional>)

#include <optional>

#define GIT_USE_STD_OPTIONAL

#elif defined(__has_include) && __has_include(<experimental/optional>)

#include <experimental/optional>

#define GIT_USE_STD_EXPERIMENTAL_OPTIONAL

#else

#include <memory>

#include <cstddef>

#endif

namespace git {

namespace internal

{

#if defined(GIT_USE_BOOST_OPTIONAL)

#undef GIT_USE_BOOST_OPTIONAL

using boost::optional;

using boost::none_t;

using boost::none;

template<typename T, typename ...Args>

optional<T> & emplace(optional<T> & opt, Args&&... args)

{

opt = boost::in_place<T>(std::forward<Args>(args)...);

return opt;

}

template<typename T>

bool has_value(optional<T> const & opt)

{

return opt.is_initialized();

}

#elif defined(GIT_USE_STD_OPTIONAL)

#undef GIT_USE_STD_OPTIONAL

using std::optional;

using none_t = std::nullopt_t;

const none_t none = std::nullopt;

template<typename T, typename ...Args>

optional<T> & emplace(optional<T> & opt, Args&&... args)

{

opt.emplace(std::forward<Args>(args)...);

return opt;

}

template<typename T>

bool has_value(optional<T> const & opt)

{

return opt.has_value();

}

#elif defined(GIT_USE_STD_EXPERIMENTAL_OPTIONAL)

#undef GIT_USE_STD_EXPERIMENTAL_OPTIONAL

using std::experimental::optional;

using none_t = std::experimental::nullopt_t;

const none_t none = std::experimental::nullopt;

template<typename T, typename ...Args>

optional<T> & emplace(optional<T> & opt, Args&&... args)

{

opt.emplace(std::forward<Args>(args)...);

return opt;

}

template<typename T>

bool has_value(optional<T> const & opt)

{

return static_cast<bool>(opt);

}

#else

typedef std::nullptr_t none_t;

const none_t none = nullptr;

//Simple (and incomplete) optional implementations

template<typename T>

class optional

{

private: //type alias

typedef typename std::aligned_storage<sizeof(T), alignof(T)>::type StorageT;

public: //type traits

enum non_movable_t{};

enum non_copyable_t{};

static const bool movable = std::is_move_constructible<T>::value && std::is_move_assignable<T>::value;

static const bool copyable = std::is_copy_constructible<T>::value && std::is_copy_assignable<T>::value;

typedef typename std::conditional<movable, T, non_movable_t>::type MovableT;

typedef typename std::conditional<copyable, T, non_copyable_t>::type CopyableT;

public: //initializing and attribution

constexpr optional(none_t t = none)

: initialized(false)

{}

optional(T const & v) { assign(v);}

optional(T && v) { assign(std::move(v));}

optional(optional const & other) { assign(other);}

optional(optional && other) { assign(std::move(other));}

optional & operator=(none_t none) { reset(); return *this;}

optional & operator=(T && v) { return assign(std::move(v));}

optional & operator=(const T & v) { return assign(v);}

optional & operator=(optional const & other){ return assign(other);}

optional & operator=(optional && other){ return assign(std::move(other));}

~optional() { reset(); }

public: //getting value

T const & value() const { return reinterpret_cast<T const &>(storage); }

T & value() { return reinterpret_cast<T &>(storage); }

T const & operator* () const { return value(); }

T & operator * () { return value(); }

T const * operator -> () const { return &value(); }

T * operator -> () { return &value(); }

public: //querying state

explicit operator bool() const { return initialized; }

public: //change state

void reset()

{

if (initialized)

{

value().~T();

initialized = false;

}

}

template<typename ...Args>

void emplace(Args&&... args){

if (initialized)

reset();

init(std::forward<Args>(args)...);

}

private: //assign

optional & assign(MovableT && value) {

return set_from_value(std::move(value));

}

optional & assign(CopyableT const & value) {

return set_from_value(value);

}

optional & assign(optional const & other) {

return set_or_reset(other.value(), other.initialized);

}

optional & assign(optional && other) {

return set_or_reset(std::move(other.value()), other.initialized);

}

protected:

template<typename U>

optional & set_or_reset(U&& u, bool isValid)

{

if (isValid)

set_from_value(std::forward<U>(u));

else

reset();

return *this;

}

template<typename U>

optional & set_from_value(U&& u)

{

if (initialized)

reinterpret_cast<T&>(storage) = std::forward<U>(u);

else

init(std::forward<U>(u));

return *this;

}

template<typename ...Args>

void init(Args&& ... args){

new (&storage) T(std::forward<Args>(args)...);

initialized = true;

}

protected:

StorageT storage;

bool initialized;

};

template<typename T, typename ...Args>

optional<T> & emplace(optional<T> & opt, Args&&... args){

opt.emplace(std::forward<Args>(args)...);

return opt;

}

template<typename T>

bool has_value(optional<T> const & opt)

{

return static_cast<bool>(opt);

}

#endif

}}//namespace git