enum class ConnectionState{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    CONNECTION_INTERRUPTED
};
struct Connection{
    ConnectionState m_connectionState;
    std::string m_serverAddress;
    std::chrono::system_clock::time_point m_connectedTime;
    std::chrono::millisecondes m_lastPingTime;
    Timer m_reconnectTimer;
};

struct Connection{
    std::string m_serverAddress;
    struct Disconnected{};
    struct Connecting{};
    struct Connected{
        ConnectionId m_id;
        std::chrono::system_clock::time_point m_connectedTime;
        std::chrono::millisecondes m_lastPingTime;
    };
    struct ConnectionInterrupted{
        std::chrono::system_clock::time_point m_disconnectedTime;
        Timer m_reconnectTimer;
    };
    std::variant<Disconnected,Connecting,Connected,ConnectionInterrupted> m_connection;
};

class Friend{
    std::string m_alias;
    bool m_aliasPopulated;
};

class UncaughtExceptionCounter {
	int getUncaughtExceptionCount() noexcept;
	int exceptionCount_ ;
public:
	UncaughtExceptionCounter()
	: exceptionCount_ (std::uncaught_exceptions()) {
	}
	bool newUncaughtException() noexcept {
		return std::uncaught_exceptions() > exceptionCount _ ;
	}
};

template <typename FunctionType, bool executeOnException>
class ScopeGuardForNewException {
	FunctionType function_ ;
	UncaughtExceptionCounter ec_ ;
public:
	explicit ScopeGuardForNewException(const FunctionType& fn)
	: function_ (fn) {}
	explicit ScopeGuardForNewException(FunctionType&& fn)
	: function_ (std::move(fn)) {}
	~ScopeGuardForNewException() noexcept(executeOnException) {
		if (executeOnException == ec_.isNewUncaughtException()) {
			function_ ();
		}
	}
};

enum class ScopeGuardOnFail {};

template <typename FunctionType>
ScopeGuardForNewException<typename std::decay<FunctionType>::type, true>
operator+(detail::ScopeGuardOnFail, FunctionType&& fn) {
	return ScopeGuardForNewException<
		typename std::decay<FunctionType>::type, true>(
			std::forward<FunctionType>(fn));
}

#define SCOPE_FAIL \
	auto ANONYMOUS_VARIABLE(SCOPE_ FAIL_STATE) \
		= ::detail::ScopeGuardOnFail() + [&]() noexcept

 template <typename Callable> class scope_exit {
   Callable ExitFunction;
   bool Engaged = true; // False once moved-from or release()d.
 
 public:
   template <typename Fp>
   explicit scope_exit(Fp &&F) : ExitFunction(std::forward<Fp>(F)) {}
 
   scope_exit(scope_exit &&Rhs)
       : ExitFunction(std::move(Rhs.ExitFunction)), Engaged(Rhs.Engaged) {
     Rhs.release();
   }
   scope_exit(const scope_exit &) = delete;
   scope_exit &operator=(scope_exit &&) = delete;
   scope_exit &operator=(const scope_exit &) = delete;
 
   void release() { Engaged = false; }
 
   ~scope_exit() {
     if (Engaged)
       ExitFunction();
   }
 };
 

  int r = memcmp(data_, b.data_, min_len);
  if (r == 0) {
    if (size_ < b.size_) r = -1;
    else if (size_ > b.size_) r = +1;
  }
  return r;

#define LOG(msg) \
    if (s_bLoggingEnabled) \
       std::cout<<__FILE__<<"("<<__LINE__<<")"<<msg<<std::endl;

using namespace std;
#define LOG(msg) \
    if (s_bLoggingEnabled) \
       (log(__FILE__,__LINE__,LogData<None>()<<msg));

template <typename List>
struct LogData{
    typedef List type;
    List list;
};
struct None{};

template <typename Begin, typename Value>
LogData<std::pair<Begin&&, Value&&>> operator<<(LogData<Begin>&& begin,
                                                Value&& v) noexcept {
    return ;
}

template <typename Begin, size_t n >
LogData<std::pair<Begin&&, const char* >> operator<<(LogData<Begin>&& begin,
                                               const char(&sz)[n]) noexcept{
    return ;
}

template<typename TLogData>
void log(const char* file, int line, TLogData&& data)
noexcept {
    std::cout<< file<<" "<<line<<": ";
    LogRecursive(std::cout, std::forward<typename TLogData::type>(data.list));
    std::cout<<std::endl;
}

template<typename TLogDataPair>
void LogRecursive(std::ostream& os, TLogDataPair&& data) noexcept{
   LogRecursive(os,std::forward<typename TLogDataPair::first_type>(data.first));
   os<<std::forward<typename TLogDataPair::second_type>(data.second);
}
inline void LogRecursive(std::ostream& os, None) noexcept{}

int main()
{
  s_bLoggingEnabled = true;
  string s{"blaa"};
  LOG("sth"<<s<<55<<"!!");
}

void callWithin(const std::function<void()>& fn){
    ScopedContext context;
    try{
        fn();
    } catch (SomeException& e){
        // handle exception here
    }
}

void printLine(const std::string& text){
    std::cout<<text<<'\n';
}
callWithin([](){printLine("Hello, CppCon");});

template <typename Callable>
void callWithin(const Callable& fn){
    ScopedContext context;
    fn();
}

double sum(double a,double b){return a+b;}
double res = callWithin([](){return sum(3.14,2.71);})

template <typename Callable> 
auto callWithin(const Callable& fn) ->decltype(fn()){
   decltype(fn()) result{};
   auto wrapperFn =[&]()->void
   {
       result = fn();
   }
   callWithImpl(wrapperFn);
   return result;
}
void callWithinImpl(const std::function<void()>& fn);

class Contextmanager{
public:
    virtual void callWithin(const std::function<void()>&fn) = 0;
};

class Contextmanager{
public:
  template <typename Fn>
  void callWithin(const Fn& fn, std::false_type) -> decltype(fn())
  {
    decltype(fn()) result{};
    callWithinImpl([&]{result=fn();});
    return result;
  }
private:
    virtual void callWithinImpl(const std::function<void()>&fn) = 0;
};

double result = manager->CallWithin([]{return sum(3.14, 2/71);});

template <typename Fn>
auto callWithin(const Fn& fn) -> decltype(fn())
{
    return _callWithin(fn, std::is_same<decltype(fn()),void>());
}
// true就直接调用，没有返回值
template <typename Fn>
void _callWithin(const Fn& fn, std::true_type) -> decltype(fn())
{
    callWithinImpl([&]{fn();});
}

template <typename Fn>
void _callWithin(const Fn& fn, std::false_type) -> decltype(fn())
{
    decltype(fn()) result{};
    callWithinImpl([&]{result=fn();});
    return result;
}

template <typename Fn>
void callWithin(const Fn& fn) -> std::optional<decltype(fn())>
{
    decltype(fn()) result{};
    bool ok = callWithinImpl([&]{result=fn();});
    if (ok)
    	return result;
    else
        return std::nullopt;
}

template <typenamet T>
void f(ParamType param);
f(expr);//  从expr推导T和ParamType

template <typename T>
void f(T& param);

int x=22;
const int cx = x;
const int& rx = x;
f(x); //  T = int,       param = int&
f(cx); // T = const int, param = const int&
f(rx); // T = const int, param = const int& 注意，此处的T ，expr是T& 直接忽略了&

template <typename T>
void f(const T& praam);

int x=22;
const int cx = x;
const int& rx = x;
f(x); //  T = int,       param = const int& 注意，此处的T ，expr是const T& 直接忽略了
f(cx); // T = const int, param = const int&
f(rx); // T = const int, param = const int& 

template <typename T>
void f(T* praam);

int x=22;
const int *pcx = &x;
f(&x);  //  T = int,       param = int *
f(pcx); //  T = const int, param = const int *

template <typename T>
void f(T&& param);
//f(expr)
int x = 22;
const int cx = x;
const int& rx = x;
f(x); //  T = int&,       param = int&
f(cx); // T = const int&, param = const int&
f(rx); // T = const int&, param = const int&   折叠了一个&
f(22); // T = int,        param = int&&  右值专属场景，完美转发

int x = 22;
const int cx = x;
const int& rx = x;

auto& v1 = x; //auto = int;
auto& v2 = cx; //auto = const int
auto& v3 = rx; // auto = const int
const auto& v4 = x; // auto = int
const auto& v5 = cx; // auto =int
const auto& v6 = rx; // auto =int
auto v7 = x;// auto =int
auto v8 = cx;// auto = int
auto v9 = rx;// auto = int
auto&& v10=rx;// type=const int&   左值，引用折叠了

void someFunc(const int* const param1,
              const int*       param2,
                    int*       param3)
{
    auto p1=param1;// auto = const int* 忽略了最后那个
    auto p2=param2;// const int*
    auto& p2v2=param2;// const int* const&，这个没忽略，注意区别
    auto p3=param3;// int*
}

template <typename T>
class TD;
template <typename T>
void f(T& param){
    TD<T> tType;
    TD<decltype(param)> paramType;
}