aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorKaren Arutyunov <karen@codesynthesis.com>2021-12-02 17:56:44 +0300
committerKaren Arutyunov <karen@codesynthesis.com>2021-12-08 15:01:54 +0300
commit88c9b1acd2b372d1405a40fb3e3802d411709fd4 (patch)
tree6a41573a624c72b1d0ba7b9245530040ef090ab4
parent14a05dc1aa9131b003d39cce9b62ab0459f6baff (diff)
Add support for three-dimensional containers emulationHEADmaster
-rw-r--r--odb/nested-container.hxx169
1 files changed, 132 insertions, 37 deletions
diff --git a/odb/nested-container.hxx b/odb/nested-container.hxx
index c7627ed..82abf0b 100644
--- a/odb/nested-container.hxx
+++ b/odb/nested-container.hxx
@@ -19,22 +19,24 @@ namespace odb
{
// Nested container emulation support for ODB.
//
- // Note that the outer key in the inner container should strictly
- // speaking be a foreign key pointing to the key of the outer
- // container. The only way to achieve this currently is to manually
- // add the constraint via ALTER TABLE ADD CONSTRAINT. Note, however,
- // that as long as we only modify these tables via the ODB container
- // interface, not having the foreign key (and not having ON DELETE
- // CASCADE) should be harmless (since we have a foreign key pointing
- // to the object id).
+ // In a nutshell, the idea is to represent a nested container, for example,
+ // vector<vector<V>>, as map<nested_key, V> where nested_key is a composite
+ // key consisting of the outer and inner container indexes.
//
-
- // Map key that is used to emulate nested container mapping in ODB.
- // Template parameter T is a tag that allows us to distinguish keys
- // for unrelated containers in order to assign column names, etc.
- // Use inner container type for T.
+ // Note that the outer key in the inner container should strictly speaking
+ // be a foreign key pointing to the key of the outer container. The only way
+ // to achieve this currently is to manually add the constraint via ALTER
+ // TABLE ADD CONSTRAINT. Note, however, that as long as we only modify these
+ // tables via the ODB container interface, not having the foreign key (and
+ // not having ON DELETE CASCADE) should be harmless (since we have a foreign
+ // key pointing to the object id).
+
+ // Map key that is used to emulate 1-level nested container mapping (for
+ // example, vector<vector<V>>). Template parameter IC is a tag that allows
+ // us to distinguish keys for unrelated containers in order to assign column
+ // names, etc. Use the inner container type (for example, vector<V>) for IC.
//
- template <typename T,
+ template <typename IC,
typename O = std::size_t,
typename I = std::size_t>
struct nested_key
@@ -54,10 +56,40 @@ namespace odb
return outer < v.outer || (outer == v.outer && inner < v.inner);
}
};
+
+ // Map key that is used to emulate 2-level nested container mapping (for
+ // example, vector<vector<vector<V>>>>). Use the middle container type for
+ // MC (for example, vector<vector<V>>).
+ //
+ template <typename MC,
+ typename O = std::size_t,
+ typename M = std::size_t,
+ typename I = std::size_t>
+ struct nested2_key
+ {
+ using outer_type = O;
+ using middle_type = M;
+ using inner_type = I;
+
+ outer_type outer;
+ middle_type middle;
+ inner_type inner;
+
+ nested2_key () = default;
+ nested2_key (outer_type o, middle_type m, inner_type i)
+ : outer (o), middle (m), inner (i) {}
+
+ bool
+ operator< (const nested2_key& v) const
+ {
+ return outer != v.outer ? outer < v.outer :
+ middle != v.middle ? middle < v.middle :
+ inner < v.inner ;
+ }
+ };
}
#include <map>
-#include <vector>
#include <cstddef> // size_t
#include <utility> // move(), declval()
#include <cassert>
@@ -65,46 +97,109 @@ namespace odb
namespace odb
{
- // vector<vector<>>
- //
- template <typename IC>
- struct nested_value_type:
- std::remove_reference<decltype (std::declval<IC> ()[0])> {};
+ template <typename C>
+ struct nested1_type:
+ std::remove_reference<decltype (std::declval<C> ()[0])> {};
+
+ template <typename C>
+ struct nested2_type:
+ std::remove_reference<decltype (std::declval<C> ()[0][0])> {};
+
+ template <typename C>
+ struct nested3_type:
+ std::remove_reference<decltype (std::declval<C> ()[0][0][0])> {};
- template <typename IC>
- std::map<nested_key<IC>, typename nested_value_type<IC>::type>
- nested_get (const std::vector<IC>& v)
+ // 1-level nesting.
+ //
+ template <typename OC> // For example, OC = vector<vector<V>>.
+ std::map<nested_key<typename nested1_type<OC>::type>,
+ typename nested2_type<OC>::type>
+ nested_get (const OC& oc)
{
using namespace std;
- using I = typename nested_value_type<IC>::type;
+ using IC = typename nested1_type<OC>::type;
+ using V = typename nested2_type<OC>::type;
using K = nested_key<IC>;
- map<K, I> r;
- for (size_t n (0); n != v.size (); ++n)
+ map<K, V> r;
+ for (size_t o (0); o != oc.size (); ++o)
{
- const IC& o (v[n]);
- for (size_t m (0); m != o.size (); ++m)
- r.emplace (K (n, m), o[m]);
+ const IC& ic (oc[o]);
+ for (size_t i (0); i != ic.size (); ++i)
+ r.emplace (K (o, i), ic[i]);
}
return r;
}
- template <typename K, typename I, typename IC>
+ template <typename K, typename V, typename OC>
void
- nested_set (std::vector<IC>& v, std::map<K, I>&& r)
+ nested_set (OC& oc, std::map<K, V>&& r)
{
using namespace std;
for (auto& p: r)
{
- size_t n (p.first.outer);
- size_t m (p.first.inner);
- I& i (p.second);
+ size_t o (p.first.outer);
+ size_t i (p.first.inner);
+ V& v (p.second);
+
+ assert (o < oc.size ());
+ assert (i == oc[o].size ());
+ oc[o].push_back (move (v));
+ }
+ }
+
+ // 2-level nesting.
+ //
+ template <typename OC> // For example, OC = vector<vector<vector<V>>>.
+ std::map<nested2_key<typename nested1_type<OC>::type>,
+ typename nested3_type<OC>::type>
+ nested2_get (const OC& oc)
+ {
+ using namespace std;
+
+ using MC = typename nested1_type<OC>::type;
+ using V = typename nested3_type<OC>::type;
+ using K = nested2_key<MC>;
+
+ map<K, V> r;
+ for (size_t o (0); o != oc.size (); ++o)
+ {
+ const auto& mc (oc[o]);
+ for (size_t m (0); m != mc.size (); ++m)
+ {
+ const auto& ic (mc[m]);
+ for (size_t i (0); i != ic.size (); ++i)
+ r.emplace (K (o, m, i), ic[i]);
+ }
+ }
+ return r;
+ }
+
+ template <typename K, typename V, typename OC>
+ void
+ nested2_set (OC& oc, std::map<K, V>&& r)
+ {
+ using namespace std;
+
+ for (auto& p: r)
+ {
+ size_t o (p.first.outer);
+ size_t m (p.first.middle);
+ size_t i (p.first.inner);
+ V& v (p.second);
+
+ assert (o < oc.size ());
+
+ auto& mc (oc[o]);
+
+ if (m >= mc.size ())
+ mc.resize (m + 1);
+
+ assert (i == mc[m].size ());
- assert (n < v.size ());
- assert (m == v[n].size ());
- v[n].push_back (move (i));
+ mc[m].push_back (move (v));
}
}
}