From 10be61ad26034a574a013c979549aaedf9aa8382 Mon Sep 17 00:00:00 2001 From: Boris Kolpackov Date: Sun, 8 Feb 2015 12:08:55 +0200 Subject: Split view/olv test into multiple headers files VC++ complains that the object file is too large. --- common/view/olv/driver.cxx | 21 +- common/view/olv/makefile | 8 +- common/view/olv/test.hxx | 687 --------------------------------------------- common/view/olv/test1.hxx | 85 ++++++ common/view/olv/test2.hxx | 123 ++++++++ common/view/olv/test3.hxx | 107 +++++++ common/view/olv/test4.hxx | 152 ++++++++++ common/view/olv/test5.hxx | 87 ++++++ common/view/olv/test6.hxx | 58 ++++ common/view/olv/test7.hxx | 52 ++++ common/view/olv/test8.hxx | 49 ++++ common/view/olv/test9.hxx | 79 ++++++ 12 files changed, 816 insertions(+), 692 deletions(-) delete mode 100644 common/view/olv/test.hxx create mode 100644 common/view/olv/test1.hxx create mode 100644 common/view/olv/test2.hxx create mode 100644 common/view/olv/test3.hxx create mode 100644 common/view/olv/test4.hxx create mode 100644 common/view/olv/test5.hxx create mode 100644 common/view/olv/test6.hxx create mode 100644 common/view/olv/test7.hxx create mode 100644 common/view/olv/test8.hxx create mode 100644 common/view/olv/test9.hxx diff --git a/common/view/olv/driver.cxx b/common/view/olv/driver.cxx index c91b8ef..b6483eb 100644 --- a/common/view/olv/driver.cxx +++ b/common/view/olv/driver.cxx @@ -16,8 +16,25 @@ #include -#include "test.hxx" -#include "test-odb.hxx" +#include "test1.hxx" +#include "test2.hxx" +#include "test3.hxx" +#include "test4.hxx" +#include "test5.hxx" +#include "test6.hxx" +#include "test7.hxx" +#include "test8.hxx" +#include "test9.hxx" + +#include "test1-odb.hxx" +#include "test2-odb.hxx" +#include "test3-odb.hxx" +#include "test4-odb.hxx" +#include "test5-odb.hxx" +#include "test6-odb.hxx" +#include "test7-odb.hxx" +#include "test8-odb.hxx" +#include "test9-odb.hxx" using namespace std; using namespace odb::core; diff --git a/common/view/olv/makefile b/common/view/olv/makefile index 9050601..c12d130 100644 --- a/common/view/olv/makefile +++ b/common/view/olv/makefile @@ -5,7 +5,8 @@ include $(dir $(lastword $(MAKEFILE_LIST)))../../../build/bootstrap.make cxx_tun := driver.cxx -odb_hdr := test.hxx +odb_hdr := test1.hxx test2.hxx test3.hxx test4.hxx test5.hxx test6.hxx \ +test7.hxx test8.hxx test9.hxx genf := $(call odb-gen,$(odb_hdr)) gen := $(addprefix $(out_base)/,$(genf)) cxx_obj := $(addprefix $(out_base)/,$(cxx_tun:.cxx=.o)) $(filter %.o,$(gen:.cxx=.o)) @@ -53,6 +54,7 @@ $(dist): sources := $(cxx_tun) $(dist): headers := $(odb_hdr) $(dist): data_dist := test.std $(dist): export name := $(name) +$(dist): export odb_header_stem := $(basename $(odb_hdr)) $(dist): export extra_dist := $(data_dist) $(call vc10projs,$(name)) \ $(call vc11projs,$(name)) $(call vc12projs,$(name)) $(dist): @@ -65,9 +67,9 @@ $(dist): # Test. # ifneq ($(db_id),common) -$(eval $(call test-rule)) +$(eval $(call test-rule,,$(filter %.sql,$(gen)))) else -$(foreach d,$(databases),$(eval $(call test-rule,$d))) +$(foreach d,$(databases),$(eval $(call test-rule,$d,$(filter %.sql,$(gen))))) endif # Clean. diff --git a/common/view/olv/test.hxx b/common/view/olv/test.hxx deleted file mode 100644 index ebc3eda..0000000 --- a/common/view/olv/test.hxx +++ /dev/null @@ -1,687 +0,0 @@ -// file : common/view/olv/test.hxx -// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC -// license : GNU GPL v2; see accompanying LICENSE file - -#ifndef TEST_HXX -#define TEST_HXX - -#include -#include -#include // unique_ptr -#include // pair - -#include -#include -#include - -// Test basic object loading functionality. -// -#pragma db namespace table("t1_") pointer(std::unique_ptr) -namespace test1 -{ - #pragma db object - struct object1 - { - object1 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} - - #pragma db id - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 (int id_ = 0, const char* s_ = ""): id (id_), s (s_) {} - - #pragma db id - int id; - - std::string s; - }; - - #pragma db view object(object1) object(object2: object1::id == object2::id) - struct view1 - { - std::unique_ptr o2; - }; - - #pragma db view object(object1) object(object2: object1::id == object2::id) - struct view2 - { - std::unique_ptr o2; - std::unique_ptr o1; - }; - - #pragma db view object(object1 = o1) object(object2 = o2: o1::id == o2::id) - struct view3 - { - std::unique_ptr o1; - std::unique_ptr o2; - }; - - #pragma db view object(object1 = o1) object(object2 = o2: o1::id == o2::id) - struct view4 - { - std::string s; - std::unique_ptr o2; - - #pragma db column(o1::id) - int id; - - std::unique_ptr o1; - int n; - }; - - #pragma db view \ - object(object1) \ - object(object2: object1::id == object2::id) \ - object(object1 = o1b: object1::id == o1b::n) - struct view5 - { - std::unique_ptr o1a; - std::unique_ptr o2; - std::unique_ptr o1b; - }; -} - -// Test loading of object pointers inside objects. -// -#pragma db namespace table("t2_") pointer(std::shared_ptr) session -namespace test2 -{ - using std::shared_ptr; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 () {} - object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} - - #pragma db id auto - int id; - - std::string s; - shared_ptr o1; - }; - - #pragma db view object(object1) object(object2) - struct view1 - { - shared_ptr o2; - }; - - #pragma db view object(object1) object(object2) - struct view2 - { - shared_ptr o2; // "Unfortunate" order. - shared_ptr o1; - }; - - #pragma db object - struct object3 - { - object3 () {} - object3 (shared_ptr o2_): o2 (o2_) {} - - #pragma db id auto - int id; - - shared_ptr o2; - }; - - #pragma db view object(object1) object(object2) object(object3) - struct view3 - { - shared_ptr o3; // "Unfortunate" order. - shared_ptr o1; - }; - - #pragma db object - struct object4 - { - #pragma db id auto - int id; - - std::vector> o2; - }; - - #pragma db view object(object4) - struct view4 - { - shared_ptr o4; - }; - - #pragma db view object(object4) object (object2) object(object1) - struct view5 - { - shared_ptr o4; // "Unfortunate" order. - shared_ptr o1; - }; - - #pragma db object - struct object5 - { - object5 () {} - object5 (shared_ptr o1_, shared_ptr o2_) - : o1 (o1_), o2 (o2_) {} - - #pragma db id auto - int id; - - shared_ptr o1; - shared_ptr o2; - }; - - #pragma db view object(object5) object (object2) \ - object(object1 = o1a: object2::o1) \ - object(object1 = o1b: object5::o1) - struct view6 - { - shared_ptr o1a; - shared_ptr o1b; - }; -} - -// Test JOINs for pointed-to objects, existing and automatically added. -// -#pragma db namespace table("t3_") pointer(std::shared_ptr) session -namespace test3 -{ - using std::shared_ptr; - - struct object2; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - - #pragma db inverse(o1) - odb::lazy_weak_ptr o2; - }; - - #pragma db object - struct object2 - { - object2 (const char* s_ = ""): s (s_) {} - - #pragma db id auto - int id; - - std::string s; - - shared_ptr o1; - }; - - #pragma db view object(object1) object(object2) - struct view1a // Existing JOIN. - { - shared_ptr o1; - }; - - #pragma db view object(object1) - struct view1b // Automatic JOIN. - { - shared_ptr o1; - }; - - // Container case. - // - struct object4; - - #pragma db object - struct object3 - { - object3 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - - #pragma db inverse(o3) - odb::lazy_weak_ptr o4; - }; - - #pragma db object - struct object4 - { - object4 (const char* s_ = ""): s (s_) {} - - #pragma db id auto - int id; - - std::string s; - - std::vector> o3; - }; - - #pragma db view object(object3) object(object4 = o4) - struct view2a // Existing JOIN. - { - shared_ptr o3; - }; - - #pragma db view object(object3) - struct view2b // Automatic JOIN. - { - shared_ptr o3; - }; -} - -// Test by-value load. -// -#pragma db namespace table("t4_") session -namespace test4 -{ - #pragma db object - struct object1 - { - object1 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} - - #pragma db id - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 (int id_ = 0, const char* s_ = "", object1* o1_ = 0) - : id (id_), s (s_), o1 (o1_) {} - - #pragma db id - int id; - - std::string s; - object1* o1; // Shallow copy. - }; - - typedef object1* object1_ptr; - typedef object2* object2_ptr; - - #pragma db view object(object1) - struct view1 - { - #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() - - #pragma db transient - object1 o1; - }; - - #pragma db view object(object1) transient - struct view1a - { - view1a (): o1_null (true) {} - - #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) \ - set(this.o1_null = !(?)) - - object1 o1; - bool o1_null; - }; - - #pragma db view object(object1) - struct view1b - { - view1b (): o1_p (0) {} - - #pragma db transient - object1 o1; - - #pragma db get(&this.o1) set(o1_p = (?)) - object1* o1_p; - }; - - #pragma db view object(object1) - struct view1c - { - view1c (object1& o1): o1_p (&o1) {} - - object1* o1_p; - }; - - #pragma db view object(object1) object(object2) transient - struct view2 - { - #pragma db member(o2_) virtual(object2_ptr) get(&this.o2) set() - #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() - - object1 o1; - object2 o2; - }; - - #pragma db view object(object1) object(object2) transient - struct view2a - { - #pragma db member(o2_) virtual(object2_ptr) get(&this.o2) \ - set(o2_null = !(?)) - #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() - - object1 o1; - object2 o2; - bool o2_null; - }; - - // Test loading into raw pointer with non-raw object pointer. - // - using std::shared_ptr; - - #pragma db object pointer(shared_ptr) - struct object3 - { - object3 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} - - #pragma db id - int id; - - int n; - }; - - #pragma db view object(object3) - struct view3 - { - // This view implements the following slightly twisted logic: if the - // object is already in the cache, then set o3_p to that. Otherwise, - // load it into the by-value instance. We can also check whether o3_p - // points to o3 to distinguish between the two outcomes. - // - - // Since we may be getting the pointer as both smart and raw, we - // need to create a bit of support code to use in the modifier - // expression. - // - void set_o3 (object3* p) {o3_p = p;} // &o3 or NULL. - void set_o3 (shared_ptr p) {o3_p = p.get ();} // From cache. - - #pragma db get(&this.o3) set(set_o3(?)) - object3* o3_p; - - #pragma db transient - object3 o3; - - // Return-by-value support (query_value()). - // - view3 (): o3_p (0) {} - view3 (const view3& x): o3_p (x.o3_p == &x.o3 ? &o3 : x.o3_p), o3 (x.o3) {} - }; -} - -// Test NULL object pointers. -// -#pragma db namespace table("t5_") pointer(std::shared_ptr) session -namespace test5 -{ - using std::shared_ptr; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 () {} - object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} - - #pragma db id auto - int id; - - std::string s; - shared_ptr o1; - }; - - #pragma db view object(object1) object(object2) - struct view1 - { - shared_ptr o1; - shared_ptr o2; - }; - - typedef std::pair comp_id; - #pragma db value(comp_id) - - #pragma db object - struct object3 - { - object3 (comp_id id_ = comp_id (), int n_ = 0): id (id_), n (n_) {} - - #pragma db id - comp_id id; - - int n; - }; - - #pragma db object - struct object4 - { - object4 () {} - object4 (const char* s_, shared_ptr o3_): s (s_), o3 (o3_) {} - - #pragma db id auto - int id; - - std::string s; - shared_ptr o3; - }; - - #pragma db view object(object3) object(object4) - struct view2 - { - shared_ptr o4; - shared_ptr o3; - }; -} - -// Test interaction with sections. -// -#pragma db namespace table("t6_") pointer(std::shared_ptr) -namespace test6 -{ - using std::shared_ptr; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 () {} - object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} - - #pragma db id auto - int id; - - std::string s; - - #pragma db load(lazy) - odb::section r; - - #pragma db section(r) - shared_ptr o1; - }; - - #pragma db view object(object1) object(object2) - struct view1 - { - shared_ptr o1; - shared_ptr o2; - }; -} - -// Test explicit conversion to smart pointer member. -// -#pragma db namespace table("t7_") pointer(*) session -namespace test7 -{ - using std::unique_ptr; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object - struct object2 - { - object2 () {} - object2 (const char* s_, object1* o1_): s (s_), o1 (o1_) {} - - #pragma db id auto - int id; - - std::string s; - object1* o1; // Shallow. - }; - - #pragma db view object(object1) object(object2) - struct view1 - { - unique_ptr o2; - unique_ptr o1; - }; -} - -// Test loading objects without id. -// -#pragma db namespace table("t8_") pointer(*) session -namespace test8 -{ - using std::unique_ptr; - - #pragma db object - struct object1 - { - object1 (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object no_id - struct object2 - { - object2 () {} - object2 (const char* s_, object1* o1_): s (s_), o1 (o1_) {} - - std::string s; - object1* o1; // Shallow. - }; - - #pragma db view object(object1) object(object2) - struct view1 - { - unique_ptr o2; - unique_ptr o1; - }; -} - -// Test loading polymorphic objects. -// -#pragma db namespace table("t9_") session -namespace test9 -{ - using std::shared_ptr; - - #pragma db object polymorphic pointer(shared_ptr) - struct root - { - virtual ~root () {} - root (int n_ = 0): n (n_) {} - - #pragma db id auto - int id; - - int n; - }; - - #pragma db object - struct base: root - { - base (int n_ = 0, const char* s_ = ""): root (n_), s (s_) {} - - std::string s; - }; - - #pragma db object - struct derived: base - { - derived (int n_ = 0, const char* s_ = "", bool b_ = false) - : base (n_, s_), b (b_) {} - - bool b; - }; - - // Load via root. - // - #pragma db view object(root) - struct view1r - { - shared_ptr o; - int n; - }; - - // Load via base. - // - #pragma db view object(base) - struct view1b - { - std::string s; - shared_ptr o; - int n; - }; - - // Load via derived. - // - #pragma db view object(derived) - struct view1d - { - std::string s; - shared_ptr o; - int n; - }; -} - -#endif // TEST_HXX diff --git a/common/view/olv/test1.hxx b/common/view/olv/test1.hxx new file mode 100644 index 0000000..eaec7e1 --- /dev/null +++ b/common/view/olv/test1.hxx @@ -0,0 +1,85 @@ +// file : common/view/olv/test1.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST1_HXX +#define TEST1_HXX + +#include +#include // unique_ptr + +#include + +// Test basic object loading functionality. +// +#pragma db namespace table("t1_") pointer(std::unique_ptr) +namespace test1 +{ + #pragma db object + struct object1 + { + object1 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} + + #pragma db id + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 (int id_ = 0, const char* s_ = ""): id (id_), s (s_) {} + + #pragma db id + int id; + + std::string s; + }; + + #pragma db view object(object1) object(object2: object1::id == object2::id) + struct view1 + { + std::unique_ptr o2; + }; + + #pragma db view object(object1) object(object2: object1::id == object2::id) + struct view2 + { + std::unique_ptr o2; + std::unique_ptr o1; + }; + + #pragma db view object(object1 = o1) object(object2 = o2: o1::id == o2::id) + struct view3 + { + std::unique_ptr o1; + std::unique_ptr o2; + }; + + #pragma db view object(object1 = o1) object(object2 = o2: o1::id == o2::id) + struct view4 + { + std::string s; + std::unique_ptr o2; + + #pragma db column(o1::id) + int id; + + std::unique_ptr o1; + int n; + }; + + #pragma db view \ + object(object1) \ + object(object2: object1::id == object2::id) \ + object(object1 = o1b: object1::id == o1b::n) + struct view5 + { + std::unique_ptr o1a; + std::unique_ptr o2; + std::unique_ptr o1b; + }; +} + +#endif // TEST1_HXX diff --git a/common/view/olv/test2.hxx b/common/view/olv/test2.hxx new file mode 100644 index 0000000..8d95470 --- /dev/null +++ b/common/view/olv/test2.hxx @@ -0,0 +1,123 @@ +// file : common/view/olv/test2.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST2_HXX +#define TEST2_HXX + +#include +#include +#include // shared_ptr + +#include + +// Test loading of object pointers inside objects. +// +#pragma db namespace table("t2_") pointer(std::shared_ptr) session +namespace test2 +{ + using std::shared_ptr; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 () {} + object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} + + #pragma db id auto + int id; + + std::string s; + shared_ptr o1; + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + shared_ptr o2; + }; + + #pragma db view object(object1) object(object2) + struct view2 + { + shared_ptr o2; // "Unfortunate" order. + shared_ptr o1; + }; + + #pragma db object + struct object3 + { + object3 () {} + object3 (shared_ptr o2_): o2 (o2_) {} + + #pragma db id auto + int id; + + shared_ptr o2; + }; + + #pragma db view object(object1) object(object2) object(object3) + struct view3 + { + shared_ptr o3; // "Unfortunate" order. + shared_ptr o1; + }; + + #pragma db object + struct object4 + { + #pragma db id auto + int id; + + std::vector> o2; + }; + + #pragma db view object(object4) + struct view4 + { + shared_ptr o4; + }; + + #pragma db view object(object4) object (object2) object(object1) + struct view5 + { + shared_ptr o4; // "Unfortunate" order. + shared_ptr o1; + }; + + #pragma db object + struct object5 + { + object5 () {} + object5 (shared_ptr o1_, shared_ptr o2_) + : o1 (o1_), o2 (o2_) {} + + #pragma db id auto + int id; + + shared_ptr o1; + shared_ptr o2; + }; + + #pragma db view object(object5) object (object2) \ + object(object1 = o1a: object2::o1) \ + object(object1 = o1b: object5::o1) + struct view6 + { + shared_ptr o1a; + shared_ptr o1b; + }; +} + +#endif // TEST2_HXX diff --git a/common/view/olv/test3.hxx b/common/view/olv/test3.hxx new file mode 100644 index 0000000..15bd71b --- /dev/null +++ b/common/view/olv/test3.hxx @@ -0,0 +1,107 @@ +// file : common/view/olv/test3.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST3_HXX +#define TEST3_HXX + +#include +#include +#include // shared_ptr + +#include +#include + +// Test JOINs for pointed-to objects, existing and automatically added. +// +#pragma db namespace table("t3_") pointer(std::shared_ptr) session +namespace test3 +{ + using std::shared_ptr; + + struct object2; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + + #pragma db inverse(o1) + odb::lazy_weak_ptr o2; + }; + + #pragma db object + struct object2 + { + object2 (const char* s_ = ""): s (s_) {} + + #pragma db id auto + int id; + + std::string s; + + shared_ptr o1; + }; + + #pragma db view object(object1) object(object2) + struct view1a // Existing JOIN. + { + shared_ptr o1; + }; + + #pragma db view object(object1) + struct view1b // Automatic JOIN. + { + shared_ptr o1; + }; + + // Container case. + // + struct object4; + + #pragma db object + struct object3 + { + object3 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + + #pragma db inverse(o3) + odb::lazy_weak_ptr o4; + }; + + #pragma db object + struct object4 + { + object4 (const char* s_ = ""): s (s_) {} + + #pragma db id auto + int id; + + std::string s; + + std::vector> o3; + }; + + #pragma db view object(object3) object(object4 = o4) + struct view2a // Existing JOIN. + { + shared_ptr o3; + }; + + #pragma db view object(object3) + struct view2b // Automatic JOIN. + { + shared_ptr o3; + }; +} + +#endif // TEST3_HXX diff --git a/common/view/olv/test4.hxx b/common/view/olv/test4.hxx new file mode 100644 index 0000000..cf2afb0 --- /dev/null +++ b/common/view/olv/test4.hxx @@ -0,0 +1,152 @@ +// file : common/view/olv/test4.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST4_HXX +#define TEST4_HXX + +#include +#include // shared_ptr + +#include + +// Test by-value load. +// +#pragma db namespace table("t4_") session +namespace test4 +{ + #pragma db object + struct object1 + { + object1 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} + + #pragma db id + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 (int id_ = 0, const char* s_ = "", object1* o1_ = 0) + : id (id_), s (s_), o1 (o1_) {} + + #pragma db id + int id; + + std::string s; + object1* o1; // Shallow copy. + }; + + typedef object1* object1_ptr; + typedef object2* object2_ptr; + + #pragma db view object(object1) + struct view1 + { + #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() + + #pragma db transient + object1 o1; + }; + + #pragma db view object(object1) transient + struct view1a + { + view1a (): o1_null (true) {} + + #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) \ + set(this.o1_null = !(?)) + + object1 o1; + bool o1_null; + }; + + #pragma db view object(object1) + struct view1b + { + view1b (): o1_p (0) {} + + #pragma db transient + object1 o1; + + #pragma db get(&this.o1) set(o1_p = (?)) + object1* o1_p; + }; + + #pragma db view object(object1) + struct view1c + { + view1c (object1& o1): o1_p (&o1) {} + + object1* o1_p; + }; + + #pragma db view object(object1) object(object2) transient + struct view2 + { + #pragma db member(o2_) virtual(object2_ptr) get(&this.o2) set() + #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() + + object1 o1; + object2 o2; + }; + + #pragma db view object(object1) object(object2) transient + struct view2a + { + #pragma db member(o2_) virtual(object2_ptr) get(&this.o2) \ + set(o2_null = !(?)) + #pragma db member(o1_) virtual(object1_ptr) get(&this.o1) set() + + object1 o1; + object2 o2; + bool o2_null; + }; + + // Test loading into raw pointer with non-raw object pointer. + // + using std::shared_ptr; + + #pragma db object pointer(shared_ptr) + struct object3 + { + object3 (int id_ = 0, int n_ = 0): id (id_), n (n_) {} + + #pragma db id + int id; + + int n; + }; + + #pragma db view object(object3) + struct view3 + { + // This view implements the following slightly twisted logic: if the + // object is already in the cache, then set o3_p to that. Otherwise, + // load it into the by-value instance. We can also check whether o3_p + // points to o3 to distinguish between the two outcomes. + // + + // Since we may be getting the pointer as both smart and raw, we + // need to create a bit of support code to use in the modifier + // expression. + // + void set_o3 (object3* p) {o3_p = p;} // &o3 or NULL. + void set_o3 (shared_ptr p) {o3_p = p.get ();} // From cache. + + #pragma db get(&this.o3) set(set_o3(?)) + object3* o3_p; + + #pragma db transient + object3 o3; + + // Return-by-value support (query_value()). + // + view3 (): o3_p (0) {} + view3 (const view3& x): o3_p (x.o3_p == &x.o3 ? &o3 : x.o3_p), o3 (x.o3) {} + }; +} + +#endif // TEST4_HXX diff --git a/common/view/olv/test5.hxx b/common/view/olv/test5.hxx new file mode 100644 index 0000000..4d291a5 --- /dev/null +++ b/common/view/olv/test5.hxx @@ -0,0 +1,87 @@ +// file : common/view/olv/test5.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST5_HXX +#define TEST5_HXX + +#include +#include // shared_ptr +#include // pair + +#include + +// Test NULL object pointers. +// +#pragma db namespace table("t5_") pointer(std::shared_ptr) session +namespace test5 +{ + using std::shared_ptr; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 () {} + object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} + + #pragma db id auto + int id; + + std::string s; + shared_ptr o1; + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + shared_ptr o1; + shared_ptr o2; + }; + + typedef std::pair comp_id; + #pragma db value(comp_id) + + #pragma db object + struct object3 + { + object3 (comp_id id_ = comp_id (), int n_ = 0): id (id_), n (n_) {} + + #pragma db id + comp_id id; + + int n; + }; + + #pragma db object + struct object4 + { + object4 () {} + object4 (const char* s_, shared_ptr o3_): s (s_), o3 (o3_) {} + + #pragma db id auto + int id; + + std::string s; + shared_ptr o3; + }; + + #pragma db view object(object3) object(object4) + struct view2 + { + shared_ptr o4; + shared_ptr o3; + }; +} + +#endif // TEST5_HXX diff --git a/common/view/olv/test6.hxx b/common/view/olv/test6.hxx new file mode 100644 index 0000000..4ef14a4 --- /dev/null +++ b/common/view/olv/test6.hxx @@ -0,0 +1,58 @@ +// file : common/view/olv/test6.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST6_HXX +#define TEST6_HXX + +#include +#include // shared_ptr + +#include +#include + +// Test interaction with sections. +// +#pragma db namespace table("t6_") pointer(std::shared_ptr) +namespace test6 +{ + using std::shared_ptr; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 () {} + object2 (const char* s_, shared_ptr o1_): s (s_), o1 (o1_) {} + + #pragma db id auto + int id; + + std::string s; + + #pragma db load(lazy) + odb::section r; + + #pragma db section(r) + shared_ptr o1; + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + shared_ptr o1; + shared_ptr o2; + }; +} + +#endif // TEST6_HXX diff --git a/common/view/olv/test7.hxx b/common/view/olv/test7.hxx new file mode 100644 index 0000000..83bd5e7 --- /dev/null +++ b/common/view/olv/test7.hxx @@ -0,0 +1,52 @@ +// file : common/view/olv/test7.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST7_HXX +#define TEST7_HXX + +#include +#include // unique_ptr + +#include + +// Test explicit conversion to smart pointer member. +// +#pragma db namespace table("t7_") pointer(*) session +namespace test7 +{ + using std::unique_ptr; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object + struct object2 + { + object2 () {} + object2 (const char* s_, object1* o1_): s (s_), o1 (o1_) {} + + #pragma db id auto + int id; + + std::string s; + object1* o1; // Shallow. + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + unique_ptr o2; + unique_ptr o1; + }; +} + +#endif // TEST7_HXX diff --git a/common/view/olv/test8.hxx b/common/view/olv/test8.hxx new file mode 100644 index 0000000..d130b79 --- /dev/null +++ b/common/view/olv/test8.hxx @@ -0,0 +1,49 @@ +// file : common/view/olv/test8.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST8_HXX +#define TEST8_HXX + +#include +#include // unique_ptr + +#include + +// Test loading objects without id. +// +#pragma db namespace table("t8_") pointer(*) session +namespace test8 +{ + using std::unique_ptr; + + #pragma db object + struct object1 + { + object1 (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object no_id + struct object2 + { + object2 () {} + object2 (const char* s_, object1* o1_): s (s_), o1 (o1_) {} + + std::string s; + object1* o1; // Shallow. + }; + + #pragma db view object(object1) object(object2) + struct view1 + { + unique_ptr o2; + unique_ptr o1; + }; +} + +#endif // TEST8_HXX diff --git a/common/view/olv/test9.hxx b/common/view/olv/test9.hxx new file mode 100644 index 0000000..18c6c32 --- /dev/null +++ b/common/view/olv/test9.hxx @@ -0,0 +1,79 @@ +// file : common/view/olv/test9.hxx +// copyright : Copyright (c) 2009-2015 Code Synthesis Tools CC +// license : GNU GPL v2; see accompanying LICENSE file + +#ifndef TEST9_HXX +#define TEST9_HXX + +#include +#include // shared_ptr + +#include + +// Test loading polymorphic objects. +// +#pragma db namespace table("t9_") session +namespace test9 +{ + using std::shared_ptr; + + #pragma db object polymorphic pointer(shared_ptr) + struct root + { + virtual ~root () {} + root (int n_ = 0): n (n_) {} + + #pragma db id auto + int id; + + int n; + }; + + #pragma db object + struct base: root + { + base (int n_ = 0, const char* s_ = ""): root (n_), s (s_) {} + + std::string s; + }; + + #pragma db object + struct derived: base + { + derived (int n_ = 0, const char* s_ = "", bool b_ = false) + : base (n_, s_), b (b_) {} + + bool b; + }; + + // Load via root. + // + #pragma db view object(root) + struct view1r + { + shared_ptr o; + int n; + }; + + // Load via base. + // + #pragma db view object(base) + struct view1b + { + std::string s; + shared_ptr o; + int n; + }; + + // Load via derived. + // + #pragma db view object(derived) + struct view1d + { + std::string s; + shared_ptr o; + int n; + }; +} + +#endif // TEST9_HXX -- cgit v1.1