//-----------------------------------------------------------------------------

// boost-libs variant/test/test7.cpp header file

// See http://www.boost.org for updates, documentation, and revision history.

//-----------------------------------------------------------------------------

//

// Copyright (c) 2003

// Eric Friedman, Itay Maman

//

// 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)

/*

 * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

*/

#include "boost/test/minimal.hpp"

#include "boost/variant.hpp"

#include "jobs.h"

#include <iostream>

#include <algorithm>

#include <string>

#include <map>

#include "boost/detail/workaround.hpp"

#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)

#   include "boost/mpl/bool.hpp"

#   include "boost/type_traits/is_same.hpp"

#endif

using namespace boost;

using namespace std;

struct jas

{

   jas(int n = 364);

   jas(const jas& other);

   ~jas();

   jas& operator=(const jas& other);

   void swap(jas& other);

   int n_;

   int sn_;

   static int s_inst_id_;

}; 

struct Tracker

{

   typedef map<const jas*,int> table_type;

   typedef table_type::iterator iterator_type;

   static table_type s_this_to_sn_;

   static void insert(const jas& j)

   {

      s_this_to_sn_[&j] = j.sn_;      

      cout << "jas( " << j.sn_ << ") Registered" << endl;

   }

   static void remove(const jas& j)

   {

      iterator_type iter = s_this_to_sn_.find(&j);

      BOOST_CHECK(iter != s_this_to_sn_.end());

      BOOST_CHECK( ((*iter).second) == j.sn_);

      int sn = (*iter).second;

      if(sn != j.sn_)

      {

         cout << "Mismatch: this = " << (*iter).first << ", sn_ = " << sn

            << ", other: this = " << &j << ", j.sn_ = " << j.sn_ << endl;

      }

      BOOST_CHECK(sn == j.sn_);

      s_this_to_sn_.erase(&j);

      cout << "jas( " << j.sn_ << ") Removed" << endl;

   }

   static void check()

   {

      BOOST_CHECK(s_this_to_sn_.empty());      

   }

};

Tracker::table_type Tracker::s_this_to_sn_;

jas::jas(int n) : n_(n) 

{ 

   sn_ = s_inst_id_;

   s_inst_id_ += 1;

   Tracker::insert(*this);

}

jas::jas(const jas& other) : n_(other.n_)

{

   sn_ = s_inst_id_;

   s_inst_id_ += 1;      

   Tracker::insert(*this);

}

jas::~jas()

{

   Tracker::remove(*this);

}

jas& jas::operator=(const jas& other)

{

   jas temp(other);

   swap(temp);

   return *this;

}

void jas::swap(jas& other)

{   

   Tracker::remove(*this);

   Tracker::remove(other);

   std::swap(n_, other.n_);

   std::swap(sn_, other.sn_);

   Tracker::insert(*this);

   Tracker::insert(other);

}

int jas::s_inst_id_ = 0;

bool operator==(const jas& a, const jas& b)

{

   return a.n_ == b.n_;

}

ostream& operator<<(ostream& out, const jas& a)

{

   cout << "jas::n_ = " << a.n_;

   return out;

}

template<typename ValueType>

struct compare_helper : boost::static_visitor<bool>

{

   compare_helper(ValueType& expected) : expected_(expected) { }

#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200)

   bool operator()(const ValueType& value)

   {

      return value == expected_;

   }

   template <typename T>

   bool operator()(const T& )

   {

      return false;         

   }

#else // MSVC6

private:

   bool compare_impl(const ValueType& value, boost::mpl::true_)

   {

      return value == expected_;

   }

   template <typename T>

   bool compare_impl(const T&, boost::mpl::false_)

   {

      return false;

   }

public:

   template <typename T>

   bool operator()(const T& value)

   {

      typedef typename boost::is_same<T, ValueType>::type

          T_is_ValueType;

      return compare_impl(value, T_is_ValueType());

   }

#endif // MSVC6 workaround

   ValueType& expected_;

};

template<typename VariantType, typename ExpectedType>

void var_compare(const VariantType& v, ExpectedType expected)

{

   compare_helper<ExpectedType> ch(expected);

   bool checks = boost::apply_visitor(ch, v);

   BOOST_CHECK(checks);

}

void run()

{   

   variant<string, short> v0;

   var_compare(v0, string(""));

   v0 = 8;

   var_compare(v0, static_cast<short>(8));

   v0 = "penny lane";

   var_compare(v0, string("penny lane"));

   variant<jas, string, int> v1, v2 = jas(195);

   var_compare(v1, jas(364));

   v1 = jas(500);

   v1.swap(v2);

   var_compare(v1, jas(195));

   var_compare(v2, jas(500));

   variant<string, int> v3;

   var_compare(v3, string(""));

}

int test_main(int , char* [])

{

std_log(LOG_FILENAME_LINE,"[Test Case for test7]");

   run();

   Tracker::check();

#ifdef __SYMBIAN32__

   	testResultXml("test7");

	close_log_file();

#endif

   return 0;

}