// file      : common/wrapper/test.hxx
// copyright : Copyright (c) 2009-2012 Code Synthesis Tools CC
// license   : GNU GPL v2; see accompanying LICENSE file

#ifndef TEST_HXX
#define TEST_HXX

#include <common/config.hxx> // HAVE_CXX11, HAVE_TR1_MEMORY

#include <string>
#include <memory> // std::auto_ptr
#include <vector>

#include <odb/core.hxx>
#include <odb/nullable.hxx>

#if !defined(HAVE_CXX11) && defined(HAVE_TR1_MEMORY)
#  include <odb/tr1/memory.hxx>
#endif

using odb::nullable;

//
// Simple values.
//

typedef nullable<std::string> nullable_string;

#ifdef HAVE_CXX11
typedef std::unique_ptr<int> num_uptr;
typedef std::unique_ptr<std::string> str_uptr;
typedef std::shared_ptr<std::string> str_sptr;
#else
typedef std::auto_ptr<int> num_uptr;
typedef std::auto_ptr<std::string> str_uptr;
#  ifdef HAVE_TR1_MEMORY
typedef std::tr1::shared_ptr<std::string> str_sptr;
#  endif
#endif

#pragma db object table("obj")
struct object
{
  #pragma db id auto
  unsigned long id_;

  num_uptr num;

  #pragma db null
  str_uptr str;

  nullable_string nstr;
  std::vector<nullable_string> nstrs;

#if defined(HAVE_CXX11) || defined(HAVE_TR1_MEMORY)
  #pragma db null
  str_sptr sstr;

  #pragma db value_null
  std::vector<str_sptr> sstrs;
#endif
};

//
// Composite values.
//

#pragma db value
struct comp1
{
  comp1 () {}
  comp1 (const std::string& s, int n): str (s), num (n) {}

  std::string str;
  int num;
};

inline bool
operator== (const comp1& x, const comp1& y)
{
  return x.str == y.str && x.num == y.num;
}


#pragma db value
struct comp2
{
  comp2 () {}
  comp2 (const std::string& s, int n): str (s), num (n) {}

  std::string str;
  int num;

  std::vector<std::string> strs;
};

inline bool
operator== (const comp2& x, const comp2& y)
{
  return x.str == y.str && x.num == y.num && x.strs == y.strs;
}

struct comp3;

#ifdef HAVE_CXX11
typedef std::unique_ptr<comp1> comp1_uptr;
typedef std::unique_ptr<comp2> comp2_uptr;
typedef std::unique_ptr<comp3> comp3_uptr;
#else
typedef std::auto_ptr<comp1> comp1_uptr;
typedef std::auto_ptr<comp2> comp2_uptr;
typedef std::auto_ptr<comp3> comp3_uptr;
#endif

#pragma db object
struct comp_object
{
  #pragma db id auto
  unsigned long id_;

  comp1_uptr                    c1;  // Wrapped comp value.
  std::vector<nullable<comp1> > vc1; // Container of wrapped comp values.
  comp2_uptr                    c2;  // Container inside wrapped comp value.
};

// This one is just a compilation test to cover more convolute cases.
//
#pragma db value
struct comp3: comp2
{
  comp1_uptr c1;
  std::vector<nullable<comp1> > vc1;
};

#pragma db object
struct comp_object2
{
  #pragma db id auto
  unsigned long id_;

  comp3_uptr c3;
};

//
// Containers.
//

#ifdef HAVE_CXX11
typedef std::unique_ptr<std::vector<int>> nums_uptr;
typedef std::unique_ptr<std::vector<std::string>> strs_uptr;
#else
typedef std::auto_ptr<std::vector<int> > nums_uptr;
typedef std::auto_ptr<std::vector<std::string> > strs_uptr;
#endif

#pragma db value
struct cont_comp
{
  int num;
  strs_uptr strs;
};

inline bool
operator== (const cont_comp& x, const cont_comp& y)
{
  return x.num == y.num && *x.strs == *y.strs;
}

#pragma db object
struct cont_object
{
  #pragma db id auto
  unsigned long id_;

  nums_uptr nums; // Wrapped container.
  cont_comp c;    // Wrapped container in comp value.
};

#endif // TEST_HXX