// Copyright (C) 2013 Vicente Botet
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/assert.hpp>
#include <boost/static_assert.hpp>
#include <vector>
#include <utility>
#include <type_traits>
#if 1

struct B {
  int v;
  B(int i) : v(i)  {}
};

struct D: B {
  D(int i) : B(i)  {}
};

void fb(B const&) {}
void fd(D const&) {}

BOOST_STATIC_ASSERT(sizeof(B)==sizeof(D));

template <class T, class Allocator=std::allocator<T> >
class new_vector;
template <class T, class Allocator>
class new_vector : public std::vector<T,Allocator>
{
  typedef std::vector<T,Allocator> base_type;
public:
  new_vector() : base_type()  {}
  new_vector(unsigned s) : base_type(s)  {}
};

template <class Allocator >
class new_vector<bool, Allocator>
{
  //std::vector<char,typename Allocator::template rebind<char>::other > v;
  int i;
public:
};

template <class T, class A>
typename std::enable_if<!std::is_same<T, bool>::value,
  new_vector<T,A>&
>::type
new_vector_cast(std::vector<T,A> & v) {
  return reinterpret_cast<new_vector<T,A>&>(v);
}

BOOST_STATIC_ASSERT(sizeof(std::vector<int>)==sizeof(new_vector<int>));
BOOST_STATIC_ASSERT(sizeof(std::vector<bool>)!=sizeof(new_vector<bool>));

void fb(std::vector<int> const&) {}
void fd(new_vector<int> const&) {}

int main() {
  {
    std::vector<int> b(1);
    b[0] = 1;
    new_vector<int> d = new_vector_cast(b);
    BOOST_ASSERT(b[0] == d[0]);
  }
  {
    //std::vector<bool> b;
    //new_vector<bool> d = new_vector_cast(b); // compile fail
  }
  {
    std::vector<int> b(1);
    b[0] = 1;
    fd(new_vector_cast(b));
  }
  {
    new_vector<int> d(1);
    d[0] = 1;
    std::vector<int> b = d;
    BOOST_ASSERT(b[0] == d[0]);
  }
  {
    //new_vector<bool> d;
    //std::vector<bool> b = d; // compile fail
  }
  {
    new_vector<int> d(1);
    d[0] = 1;
    fd(d);
  }
  return 0;
}


#else
int main() {
  {
    B b(1);
    D d = reinterpret_cast<D&>(b);
    BOOST_ASSERT(b.v == d.v);
  }
  {
    B b(1);
    fd(reinterpret_cast<D&>(b));
  }
  {
    D d(2);
    B b = d;
    BOOST_ASSERT(b.v == d.v);
  }
  {
    D d(2);
    fd(d);
  }
  return 0;
}

#define BOOST_THREAD_VERSION 4

#include <iostream>
#include <boost/thread.hpp>

int calculate_the_answer_to_life_the_universe_and_everything()
{
return 42;
}

int main()
{
boost::packaged_task<int()> pt(calculate_the_answer_to_life_the_universe_and_everything);
boost::shared_future<int> fi1 = boost::shared_future<int>(pt.get_future());
boost::shared_future<int> fi2 = fi1;

boost::thread task(boost::move(pt)); // launch task on a thread

boost::wait_for_any(fi1, fi2);
std::cout << "Wait for any returned\n";
return (0);
}
#endif