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

#ifndef TEST_HXX
#define TEST_HXX

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

#include <map>
#include <set>
#include <list>
#include <vector>
#include <deque>
#include <string>

#ifdef HAVE_CXX11
#  include <array>
#  include <forward_list>
#  include <unordered_map>
#  include <unordered_set>
#endif

#include <odb/core.hxx>

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

  #pragma db column("number")
  int num;
  std::string str;
};

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

inline bool
operator!= (const comp& x, const comp& y)
{
  return !(x == y);
}

inline bool
operator< (const comp& x, const comp& y)
{
  return x.num != y.num ? x.num < y.num : x.str < y.str;
}

typedef std::list<std::string> str_list;
typedef std::deque<int> num_deque;

typedef std::vector<int> num_vector;
typedef std::vector<std::string> str_vector;

typedef std::set<int> num_set;
typedef std::set<std::string> str_set;
typedef std::set<comp> comp_set;

typedef std::map<int, std::string> num_str_map;
typedef std::map<std::string, int> str_num_map;
typedef std::map<int, comp> num_comp_map;
typedef std::map<comp, std::string> comp_str_map;

#ifdef HAVE_CXX11
struct comp_hash
{
  std::size_t
  operator() (const comp& x) const {return nh (x.num) + sh (x.str);}

  std::hash<int> nh;
  std::hash<std::string> sh;
};

typedef std::array<int, 3> num_array;
typedef std::array<std::string, 3> str_array;
typedef std::array<comp, 3> comp_array;

typedef std::forward_list<int> num_flist;
typedef std::forward_list<std::string> str_flist;
typedef std::forward_list<comp> comp_flist;

typedef std::unordered_set<int> num_uset;
typedef std::unordered_set<std::string> str_uset;
typedef std::unordered_set<comp, comp_hash> comp_uset;

typedef std::unordered_map<int, std::string> num_str_umap;
typedef std::unordered_map<std::string, int> str_num_umap;
typedef std::unordered_map<int, comp> num_comp_umap;
typedef std::unordered_map<comp, std::string, comp_hash> comp_str_umap;
#endif

#pragma db value
struct cont_comp1
{
  // This composite value does not have any columns.
  //
  num_vector sv; // Have the name "conflic" with the one in the object.
};

#pragma db value
struct cont_comp2
{
  cont_comp2 (): num (777), str ("ggg") {}

  int num;
  str_list sl;
  std::string str;
};

#pragma db object
struct object
{
  object (): nv (comp1_.sv), sl (comp2_.sl) {}
  object (const std::string& id) : id_ (id), nv (comp1_.sv), sl (comp2_.sl) {}

  #pragma db id
  std::string id_;

  int num;

  cont_comp1 comp1_;
  cont_comp2 comp2_;

  // vector
  //
  #pragma db transient
  num_vector& nv;

  #pragma db table("object_strings") id_column ("obj_id")
  str_vector sv;

  #pragma db value_column("")
  std::vector<comp> cv;

  #pragma db unordered
  num_vector uv;

  // list
  //
  #pragma db transient
  str_list& sl;

  // deque
  //
  num_deque nd;

  // set
  //
  num_set ns;
  str_set ss;
  comp_set cs;

  // map
  //
  num_str_map nsm;
  str_num_map snm;
  num_comp_map ncm;
  comp_str_map csm;

#ifdef HAVE_CXX11
  // array
  //
  num_array na;
  str_array sa;
  comp_array ca;

  // forward_list
  //
  num_flist nfl;
  str_flist sfl;
  comp_flist cfl;

  // unordered_set
  //
  num_uset nus;
  str_uset sus;
  comp_uset cus;

  // unordered_map
  //
  num_str_umap nsum;
  str_num_umap snum;
  num_comp_umap ncum;
  comp_str_umap csum;
#else
  // Dummy containers to get the equivalent DROP TABLE statements.
  //
  num_vector na;
  num_vector sa;
  num_vector ca;

  num_vector nfl;
  num_vector sfl;
  num_vector cfl;

  num_set nus;
  str_set sus;
  comp_set cus;

  num_str_map nsum;
  str_num_map snum;
  num_comp_map ncum;
  comp_str_map csum;
#endif

  std::string str;
};

inline bool
operator== (const object& x, const object& y)
{
  if (x.uv.size () != y.uv.size ())
    return false;

  int xs (0), ys (0);

  for (num_vector::size_type i (0); i < x.uv.size (); ++i)
  {
    xs += x.uv[i];
    ys += y.uv[i];
  }

  return
    x.id_ == y.id_ &&
    x.num == y.num &&

    x.comp2_.num == y.comp2_.num &&
    x.comp2_.str == y.comp2_.str &&

    x.nv == y.nv &&
    x.sv == y.sv &&
    x.cv == y.cv &&
    xs == ys &&

    x.sl == y.sl &&

    x.nd == y.nd &&

    x.ns == y.ns &&
    x.ss == y.ss &&
    x.cs == y.cs &&

    x.nsm == y.nsm &&
    x.snm == y.snm &&
    x.ncm == y.ncm &&
    x.csm == y.csm &&

#ifdef HAVE_CXX11
    x.na == y.na &&
    x.sa == y.sa &&
    x.ca == y.ca &&

    x.nfl == y.nfl &&
    x.sfl == y.sfl &&
    x.cfl == y.cfl &&

    x.nus == y.nus &&
    x.sus == y.sus &&
    x.cus == y.cus &&

    x.nsum == y.nsum &&
    x.snum == y.snum &&
    x.ncum == y.ncum &&
    x.csum == y.csum &&
#endif

    x.str == y.str;
}

#endif // TEST_HXX