#ifndef MACE_FWD_HPP_
#define MACE_FWD_HPP_
#include <utility>
#include <new>

namespace detail {
  template<typename A, typename U>
  struct add {
    typedef decltype( *((A*)0) + *((typename std::remove_reference<U>::type*)0) ) type; 
  };
  template<typename A, typename U>
  struct add_eq {
    typedef decltype( *((A*)0) += *((typename std::remove_reference<U>::type*)0) ) type; 
  };

  template<typename A, typename U>
  struct sub {
    typedef decltype( *((A*)0) - *((typename std::remove_reference<U>::type*)0) ) type; 
  };

  template<typename A, typename U>
  struct sub_eq {
    typedef decltype( *((A*)0) -= *((typename std::remove_reference<U>::type*)0) ) type; 
  };
  template<typename A, typename U>
  struct insert_op {
    typedef decltype( *((A*)0) << *((typename std::remove_reference<U>::type*)0) ) type; 
  };
  template<typename A, typename U>
  struct extract_op {
    A* a;
    U* u;
    typedef decltype( *a >> *u ) type;
  };
}

template<typename T,unsigned int S>
class fwd {
  public:
    template<typename U>
    fwd( U&& u ) {
      static_assert( sizeof(_store) >= sizeof(*this), "Failed to reserve enough space" );
      new (this) T( std::forward<U>(u) );
    }
    fwd() {
      static_assert( sizeof(_store) >= sizeof(*this), "Failed to reserve enough space" );
      new (this) T();
    }

    fwd( const fwd& f ){
      new (this) T( *f );
    }
    fwd( fwd&& f ){
      new (this) T( std::move(*f) );
    }

    template<typename U>
    operator U () {
      return *((T*)this);
    }
    template<typename U>
    operator const U&() {
      return *((const T*)this);
    }

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

    T* operator->(){
      return ((T*)this);
    }
    bool operator !()const { return !(**this); }

    template<typename U>
    friend auto operator + ( const fwd<T,S>& x, U&& u ) -> typename detail::add<T,U>::type { return *x+std::forward<U>(u); }

    template<typename U>
    auto operator += ( U&& u ) -> typename detail::add_eq<T,U>::type { return **this+=std::forward<U>(u); }

    template<typename U>
    friend auto operator - ( const fwd<T,S>& x, U&& u ) -> typename detail::sub<T,U>::type { return *x-std::forward<U>(u); }

    template<typename U>
    auto operator -= ( U&& u ) -> typename detail::sub_eq<T,U>::type { return **this-=std::forward<U>(u); }

    template<typename U>
    friend auto operator << ( U& u, const fwd& f ) -> typename detail::insert_op<U,T>::type { return u << *f; }

    template<typename U>
    friend auto operator >> ( U& u, fwd& f ) -> typename detail::extract_op<U,T>::type { return u >> *f; }

    ~fwd() {
      ((T*)this)->~T();
    }
  private:
    union {
      double _force_align;
      char _data[S];
    } _store;
};

#endif

struct test;


class A {
  public:
  A();
  
  private:
  fwd<test,4> x;
};



struct test {
  test( int _a ):a(_a),b(99){}

  operator double()const { return a/b; }
  bool operator!()const { return true; }
  friend test  operator + ( const test& t, double x ) { return test(t.a + x); }
  test&  operator += ( double x ) { a += x; return *this; }

  char a;
  int b;
};
#include <iostream>
std::ostream& operator<<(std::ostream& o, const test& t ) {
  return o << t.a << t.b;
}

std::istream& operator>>(std::istream& o, test& t ) {
  return o >> t.a >> t.b;
}

A::A():x(500){
  std::cerr<<sizeof(A)<<"\n";
  std::cerr<<x->a<<std::endl;
  double v = x + 6.6;
  x += 20;
  std::cerr<<x; 
  std::cin >> x;
  std::cerr<<x; 
}

int main( int argc, char** argv ) {
  A x;
  return 0;
}