1 files changed, 268 insertions, 0 deletions
diff --git a/common/container/basics/test.hxx b/common/container/basics/test.hxx
new file mode 100644
index 0000000..e88edd9
--- /dev/null
+++ b/common/container/basics/test.hxx
@@ -0,0 +1,268 @@
+// file      : common/container/basics/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
+
+#include <map>
+#include <set>
+#include <list>
+#include <vector>
+#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::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() (comp const& 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;
+
+  // 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.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